Add reproduce method to Player and add self.init_args to appropriate strategies

Author: marcharper

axelrod/player.py

@@ -28,7 +28,6 @@ def is_cheater(s):
            classifier['manipulates_source'] or\
            classifier['manipulates_state']
 
-
 def update_histories(player1, player2, move1, move2):
     """Updates histories and cooperation / defections counts following play."""
     # Update histories
@@ -73,6 +72,7 @@ def __init__(self):
         self.tournament_attributes = {'length': -1, 'game': None}
         self.cooperations = 0
         self.defections = 0
+        self.init_args = ()
 
     def __repr__(self):
         """The string method for the strategy."""
@@ -98,6 +98,16 @@ def play(self, opponent, noise=0):
             s1, s2 = self._add_noise(noise, s1, s2)
         update_histories(self, opponent, s1, s2)
 
+    def reproduce(self):
+        """Clones the player without history, reapplying configuration
+        parameters as necessary."""
+
+        cls = self.__class__
+        #print(cls)
+        #print(self.init_args)
+        new_player = cls(*self.init_args)
+        return new_player
+
     def reset(self):
         """Resets history.
 

axelrod/round_robin.py

@@ -80,15 +80,21 @@ def _pair_of_players(self, player1_index, player2_index):
         player1 = self.players[player1_index]
         class1 = player1.__class__
         if player1_index == player2_index:
-            # Check for arguments in __init__. If more than one (self), then
-            # deepcopy rather than instantiating the class variable
-            argspec = inspect.getargspec(player1.__init__)
-            if len(argspec.args) > 1:
-                player2 = copy.deepcopy(player1)
-            else:
-                player2 = class1()
-                player2.tournament_attributes = player1.tournament_attributes
             class2 = class1
+            try:
+                player2 = player1.reproduce()
+            except TypeError:
+                print(class1)
+                exit()
+            ## Check for arguments in __init__. If more than one (self), then
+            ## deepcopy rather than instantiating the class variable
+            #argspec = inspect.getargspec(player1.__init__)
+            #if len(argspec.args) > 1:
+                #player2 = copy.deepcopy(player1)
+            #else:
+                #player2 = class1()
+                #player2.tournament_attributes = player1.tournament_attributes
+            #class2 = class1
         else:
             player2 = self.players[player2_index]
             class2 = player2.__class__

axelrod/strategies/axelrod_tournaments.py

@@ -29,6 +29,7 @@ class Davis(Player):
     def __init__(self, rounds_to_cooperate=10):
         Player.__init__(self)
         self._rounds_to_cooperate = rounds_to_cooperate
+        self.init_args = (self._rounds_to_cooperate,)
 
     def strategy(self, opponent):
         """Begins by playing C, then plays D for the remaining rounds if the
@@ -61,6 +62,9 @@ def __init__(self, start_coop_prob=1.0, end_coop_prob=0.5,
         self._start_coop_prob = start_coop_prob
         self._end_coop_prob = end_coop_prob
         self._rounds_of_decay = rounds_of_decay
+        self.init_args = (start_coop_prob,
+                          end_coop_prob,
+                          rounds_of_decay)
 
     def _cooperation_probability(self):
         """It's not clear what the interpolating function is, so we'll do
@@ -95,6 +99,7 @@ def __init__(self):
         p = float(2) / 7
         four_vector = (p, p, p, p)
         super(self.__class__, self).__init__(four_vector)
+        self.init_args = ()
 
 
 class Joss(MemoryOnePlayer):
@@ -109,6 +114,7 @@ def __init__(self, p=0.9):
         four_vector = (p, 0, p, 0)
         self.p = p
         super(self.__class__, self).__init__(four_vector)
+        self.init_args = (p,)
 
     def __repr__(self):
         return "%s: %s" % (self.name, round(self.p, 2))
@@ -192,6 +198,7 @@ def __init__(self, rounds_to_cooperate=11):
         Player.__init__(self)
         self._rounds_to_cooperate = rounds_to_cooperate
         self.__class__.memory_depth = rounds_to_cooperate
+        self.init_args = (rounds_to_cooperate,)
 
     def strategy(self, opponent):
         rounds = self._rounds_to_cooperate

axelrod/strategies/cycler.py

@@ -54,6 +54,7 @@ def __init__(self, cycle="CCD"):
         self.cycle = cycle
         self.name += " " + cycle
         self.classifier['memory_depth'] = len(cycle) - 1
+        self.init_args = (cycle,)
 
     def strategy(self, opponent):
         curent_round = len(self.history)

axelrod/strategies/darwin.py

@@ -43,7 +43,6 @@ def __init__(self):
         super(Darwin, self).__init__()
         self.response = self.__class__.genome[0]
 
-
     def strategy(self, opponent):
         # Frustrate psychics and ensure that simulated rounds
         # do not influence genome.
@@ -68,13 +67,11 @@ def strategy(self, opponent):
 
         return current
 
-
     def reset(self):
         """ Reset instance properties. """
         Player.reset(self)
         self.__class__.genome[0] = 'C' # Ensure initial Cooperate
 
-
     def mutate(self, outcome, trial):
         """ Select response according to outcome. """
         if outcome < 0 and (len(self.__class__.genome) >= trial):

axelrod/strategies/gobymajority.py

@@ -21,6 +21,7 @@ def __init__(self, memory_depth=0, soft=True):
         Player.__init__(self)
         self.soft = soft
         self.classifier['memory_depth'] = memory_depth
+        self.init_args = (memory_depth, soft)
 
     def strategy(self, opponent):
         """This is affected by the history of the opponent.
@@ -58,32 +59,34 @@ class GoByMajority40(GoByMajority):
     GoByMajority player with a memory of 40.
     """
 
-    def __init__(self, memory_depth=40):
-        super(self.__class__, self).__init__(memory_depth=memory_depth)
+    def __init__(self, memory_depth=40, soft=True):
+        super(self.__class__, self).__init__(memory_depth=memory_depth,
+                                             soft=soft)
 
 
 class GoByMajority20(GoByMajority):
     """
     GoByMajority player with a memory of 20.
     """
 
-    def __init__(self, memory_depth=20):
-        super(self.__class__, self).__init__(memory_depth=memory_depth)
-
+    def __init__(self, memory_depth=20, soft=True):
+        super(self.__class__, self).__init__(memory_depth=memory_depth,
+                                             soft=soft)
 
 class GoByMajority10(GoByMajority):
     """
     GoByMajority player with a memory of 10.
     """
 
-    def __init__(self, memory_depth=10):
-        super(self.__class__, self).__init__(memory_depth=memory_depth)
-
+    def __init__(self, memory_depth=10, soft=True):
+        super(self.__class__, self).__init__(memory_depth=memory_depth,
+                                             soft=soft)
 
 class GoByMajority5(GoByMajority):
     """
     GoByMajority player with a memory of 5.
     """
 
-    def __init__(self, memory_depth=5):
-        super(self.__class__, self).__init__(memory_depth=memory_depth)
+    def __init__(self, memory_depth=5, soft=True):
+        super(self.__class__, self).__init__(memory_depth=memory_depth,
+                                             soft=soft)

axelrod/strategies/grumpy.py

@@ -24,6 +24,7 @@ def __init__(self, starting_state='Nice', grumpy_threshold=10,
         self.starting_state = starting_state
         self.grumpy_threshold = grumpy_threshold
         self.nice_threshold = nice_threshold
+        self.init_args = (starting_state, grumpy_threshold, nice_threshold)
 
     def strategy(self, opponent):
         """A player that gets grumpier the more the opposition defects,

axelrod/strategies/memoryone.py

@@ -25,8 +25,9 @@ def __init__(self, initial='C'):
             ('D', 'C'): 'D',
             ('D', 'D'): 'C',
         }
-        self._initial = initial
         self.classifier['stochastic'] = False
+        self._initial = initial
+        self.init_args = (initial,)
 
     def strategy(self, opponent):
         """Switches if it doesn't get the best payout, traditionally equivalent
@@ -58,6 +59,7 @@ def __init__(self, four_vector, initial='C'):
         self._four_vector = dict(zip([('C', 'C'), ('C', 'D'), ('D', 'C'), ('D', 'D')], map(float, four_vector)))
         self._initial = initial
         self.classifier['stochastic'] = any(0 < x < 1 for x in set(four_vector))
+        self.init_args = (four_vector, initial)
 
     def strategy(self, opponent):
         if not len(opponent.history):
@@ -83,6 +85,7 @@ def __init__(self, p=None):
         self.p = p
         four_vector = [1, p, 1, p]
         super(self.__class__, self).__init__(four_vector)
+        self.init_args = (p,)
 
     def __repr__(self):
         return "%s: %s" % (self.name, round(self.p, 2))
@@ -107,6 +110,7 @@ def __init__(self, ep=0.05):
         self.ep = ep
         four_vector = (1.-ep, ep, ep, 1.-ep)
         super(self.__class__, self).__init__(four_vector)
+        self.init_args = (ep,)
 
 
 class ZeroDeterminantPlayer(MemoryOnePlayer):
@@ -137,16 +141,18 @@ def __init__(self, phi=0., s=None, l=None):
 
         four_vector = [p1, p2, p3, p4]
         MemoryOnePlayer.__init__(self, four_vector)
+        self.init_args = (phi, s, l)
 
 
 class ZDGTFT2(ZeroDeterminantPlayer):
     """A Generous Zero Determinant Strategy."""
 
     name = 'ZD-GTFT-2'
 
-    def __init__(self, phi=0., chi=2.):
+    def __init__(self):
         (R, P, S, T) = Game().RPST()
         ZeroDeterminantPlayer.__init__(self, phi=0.25, s=0.5, l=R)
+        self.init_args = ()
 
 
 class ZDExtort2(ZeroDeterminantPlayer):
@@ -157,6 +163,7 @@ class ZDExtort2(ZeroDeterminantPlayer):
     def __init__(self):
         (R, P, S, T) = Game().RPST()
         ZeroDeterminantPlayer.__init__(self, phi=1./9, s=0.5, l=P)
+        self.init_args = ()
 
 
 ### Strategies for recreating tournaments
@@ -174,6 +181,7 @@ def __init__(self, q=0.9):
         four_vector = (1., 1 - q, 1, 1 - q)
         super(self.__class__, self).__init__(four_vector)
         self.q = q
+        self.init_args = (q,)
 
     def __repr__(self):
         return "%s: %s" % (self.name, round(self.q, 2))

axelrod/strategies/meta.py

@@ -97,6 +97,7 @@ def __init__(self, team=None):
             self.team = ordinary_strategies
 
         MetaPlayer.__init__(self)
+        self.init_args = (team,)
 
         # For each player, we will keep the history of proposed moves and
         # a running score since the beginning of the game.

axelrod/strategies/mindreader.py

@@ -54,9 +54,6 @@ class MindReader(Player):
         'manipulates_state': True
     }
 
-    def __init__(self):
-        Player.__init__(self)
-
     def strategy(self, opponent):
         """Pretends to play the opponent a number of times before each match.
         The primary purpose is to look far enough ahead to see if a defect will

axelrod/strategies/oncebitten.py

@@ -100,6 +100,7 @@ def __init__(self, forget_probability = 0.05):
         self.D_count = 0
         self._initial = 'C'
         self.forget_probability = forget_probability
+        self.init_args = (forget_probability,)
 
     def strategy(self, opponent):
         r = random.random()
@@ -133,10 +134,6 @@ class FoolMeForever(Player):
         'manipulates_state': False
     }
 
-    def __init__(self):
-        Player.__init__(self)
-        self.classifier['stochastic'] = False
-
     def strategy(self, opponent):
         if opponent.defections > 0:
             return 'C'

axelrod/strategies/rand.py

@@ -17,6 +17,7 @@ class Random(Player):
     def __init__(self, p=0.5):
         Player.__init__(self)
         self.p = p
+        self.init_args = (p,)
 
     def strategy(self, opponent):
         r = random.random()

axelrod/strategies/retaliate.py

@@ -27,6 +27,7 @@ def __init__(self, retaliation_threshold=0.1):
             'Retaliate (' +
             str(self.retaliation_threshold) + ')')
         self.play_counts = defaultdict(int)
+        self.init_args = (retaliation_threshold,)
 
     def strategy(self, opponent):
         """
@@ -94,6 +95,7 @@ def __init__(self, retaliation_threshold = 0.1, retaliation_limit = 20,):
         self.retaliation_threshold = retaliation_threshold
         self.retaliation_limit = retaliation_limit
         self.play_counts = defaultdict(int)
+        self.init_args = (retaliation_threshold, retaliation_limit)
 
         self.name = (
             'Limited Retaliate (' +