Merge pull request #295 from Axelrod-Python/294

294 - adds classifier dictionary and applies to all strategies with tests

Author: marcharper

axelrod/__init__.py

@@ -10,4 +10,4 @@
 from .tournament import *
 from .tournament_manager import *
 from .strategies import *
-from .ecosystem import *
+from .ecosystem import *

axelrod/player.py

@@ -1,5 +1,6 @@
 import inspect
 import random
+import copy
 
 C, D = 'C', 'D'
 flip_dict = {C: D, D: C}
@@ -28,14 +29,27 @@ class Player(object):
     """
 
     name = "Player"
+    classifier = {}
+    default_classifier = {
+        'stochastic': False,
+        'memory_depth': float('inf'),
+        'inspects_source': None,
+        'manipulates_source': None,
+        'manipulates_state': None
+    }
 
     def __init__(self):
         """Initiates an empty history and 0 score for a player."""
         self.history = []
-        self.stochastic = "random" in inspect.getsource(self.__class__)
-        self.tournament_attributes = {'length': -1, 'game': None}
+        self.classifier = copy.copy(self.classifier)
+        self.classifier['stochastic'] = (
+            "random" in inspect.getsource(self.__class__))
         if self.name == "Player":
-            self.stochastic = False
+            self.classifier['stochastic'] = False
+        for dimension in self.default_classifier:
+            if dimension not in self.classifier:
+                self.classifier[dimension] = self.default_classifier[dimension]
+        self.tournament_attributes = {'length': -1, 'game': None}
         self.cooperations = 0
         self.defections = 0
 

axelrod/round_robin.py

@@ -97,8 +97,8 @@ def _pair_of_players(self, player1_index, player2_index):
     def _stochastic_interaction(self, player1, player2):
         return (
             self._noise or
-            player1.stochastic or
-            player2.stochastic)
+            player1.classifier['stochastic'] or
+            player2.classifier['stochastic'])
 
     def _play_single_interaction(self, player1, player2, classes):
         turn = 0
@@ -130,7 +130,7 @@ def _cache_update_required(self, p1, p2):
         return (
             not self._noise and
             self.cache_mutable and
-            not (p1.stochastic or p2.stochastic))
+            not (p1.classifier['stochastic'] or p2.classifier['stochastic']))
 
     def _calculate_cooperation(self, player):
         return player.history.count('C')

axelrod/strategies/_strategies.py

@@ -30,7 +30,7 @@
 from .retaliate import *
 from .titfortat import *
 
-
+# A list of strategies to quickly create a tournament
 basic_strategies = [
     Alternator,
     Cooperator,
@@ -39,12 +39,13 @@
     TitForTat,
 ]
 
-ordinary_strategies = [
+# All the strategies in the tournament
+strategies = basic_strategies + [
     Aggravater,
     AlternatorHunter,
-    Appeaser,
     AntiCycler,
     AntiTitForTat,
+    Appeaser,
     ArrogantQLearner,
     AverageCopier,
     BackStabber,
@@ -53,33 +54,37 @@
     CautiousQLearner,
     Champion,
     CooperatorHunter,
-    CyclerCCD,
-    CyclerCCCD,
     CyclerCCCCCD,
+    CyclerCCCD,
+    CyclerCCD,
+    Darwin,
     Davis,
     DefectorHunter,
     DoubleCrosser,
     Eatherley,
-    FoolMeOnce,
+    Feld,
     FoolMeForever,
+    FoolMeOnce,
     ForgetfulFoolMeOnce,
     ForgetfulGrudger,
     Forgiver,
     ForgivingTitForTat,
     GTFT,
+    Geller,
+    GellerCooperator,
+    GellerDefector,
     GoByMajority,
     GoByMajority10,
     GoByMajority20,
     GoByMajority40,
     GoByMajority5,
-    Feld,
     Golden,
     Grofman,
     Grudger,
     Grumpy,
     HardProber,
-    HardTitForTat,
     HardTitFor2Tats,
+    HardTitForTat,
     HesitantQLearner,
     Inverse,
     InversePunisher,
@@ -92,22 +97,27 @@
     MetaMajority,
     MetaMinority,
     MetaWinner,
+    MindBender,
+    MindController,
+    MindReader,
+    MindWarper,
     NiceAverageCopier,
     OnceBitten,
     OppositeGrudger,
     Pi,
     Prober,
     Prober2,
     Prober3,
+    ProtectedMindReader,
     Punisher,
     RandomHunter,
     Retaliate,
     Retaliate2,
     Retaliate3,
     RiskyQLearner,
     Shubik,
-    SoftJoss,
     SneakyTitForTat,
+    SoftJoss,
     StochasticWSLS,
     SuspiciousTitForTat,
     Tester,
@@ -120,17 +130,17 @@
     ZDExtort2,
     ZDGTFT2,
     e,
-]
+    ]
 
-# These are strategies that do not follow the rules of Axelrods tournament
-cheating_strategies = [
-    Darwin,
-    Geller,
-    GellerCooperator,
-    GellerDefector,
-    MindBender,
-    MindController,
-    MindReader,
-    MindWarper,
-    ProtectedMindReader,
-]
+
+def is_cheater(s):
+    """
+    A function to check if a strategy cheats.
+    """
+    classifier = s.classifier
+    return classifier['inspects_source'] or\
+           classifier['manipulates_source'] or\
+           classifier['manipulates_state']
+
+ordinary_strategies = [s for s in strategies if not is_cheater(s)]
+cheating_strategies = [s for s in strategies if is_cheater(s)]

axelrod/strategies/alternator.py

@@ -5,7 +5,13 @@ class Alternator(Player):
     """A player who alternates between cooperating and defecting."""
 
     name = 'Alternator'
-    memory_depth = 1
+    classifier = {
+        'memory_depth': 1,
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def strategy(self, opponent):
         if len(self.history) == 0:

axelrod/strategies/appeaser.py

@@ -4,12 +4,18 @@
 class Appeaser(Player):
     """A player who tries to guess what the opponent wants.
 
-    Switch the behaviour every time the opponent plays 'D'.
+    Switch the classifier every time the opponent plays 'D'.
     Start with 'C', switch between 'C' and 'D' when opponent plays 'D'.
     """
 
     name = 'Appeaser'
-    memory_depth = float('inf')  # Depends on internal memory.
+    classifier = {
+        'memory_depth': float('inf'),  # Depends on internal memory.
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def strategy(self, opponent):
         if not len(self.history):

axelrod/strategies/averagecopier.py

@@ -8,7 +8,13 @@ class AverageCopier(Player):
     """The player will cooperate with probability p if the opponent's cooperation ratio is p."""
 
     name = 'Average Copier'
-    memory_depth = float('inf')  # Long memory
+    classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': True,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     @staticmethod
     def strategy(opponent):
@@ -21,11 +27,18 @@ def strategy(opponent):
             return 'C'
         return 'D'
 
+
 class NiceAverageCopier(Player):
     """Same as Average Copier, but always starts by cooperating."""
 
     name = 'Nice Average Copier'
-    memory_depth = float('inf')  # Long memory
+    classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': True,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     @staticmethod
     def strategy(opponent):

axelrod/strategies/axelrod_tournaments.py

@@ -16,7 +16,13 @@ class Davis(Player):
     defecting if at any point the opponent has defected."""
 
     name = 'Davis'
-    memory_depth = float('inf')  # Long memory
+    classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def __init__(self, rounds_to_cooperate=10):
         Player.__init__(self)
@@ -39,7 +45,13 @@ class Feld(Player):
     """
 
     name = "Feld"
-    memory_depth = 200 # Varies actually, eventually becomes depth 1
+    classifier = {
+        'memory_depth': 200, # Varies actually, eventually becomes depth 1
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def __init__(self, start_coop_prob=1.0, end_coop_prob=0.5,
                  rounds_of_decay=200):
@@ -78,7 +90,13 @@ class Shubik(Player):
     """
 
     name = 'Shubik'
-    memory_depth = float('inf')
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def __init__(self):
         Player.__init__(self)
@@ -129,7 +147,13 @@ class Tullock(Player):
     than the opponent has in previous rounds."""
 
     name = "Tullock"
-    memory_depth = 11 # long memory, modified by init
+    classifier = {
+        'memory_depth': 11, # long memory, modified by init
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def __init__(self, rounds_to_cooperate=11):
         Player.__init__(self)
@@ -157,7 +181,13 @@ class Champion(Player):
     """
 
     name = "Champion"
-    memory_depth = float('inf')
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def strategy(self, opponent):
         current_round = len(self.history)
@@ -185,7 +215,13 @@ class Eatherley(Player):
     """
 
     name = "Eatherley"
-    memory_depth = float('inf')
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def strategy(self, opponent):
         # Cooperate on the first move
@@ -212,7 +248,13 @@ class Tester(Player):
     """
 
     name = "Tester"
-    memory_depth = float('inf')
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
 
     def __init__(self):
         Player.__init__(self)