Automatically set strategy classes (and transformers) __repr__ to include parameters. #802

.gitignore

@@ -102,9 +102,12 @@ ENV/
 # Rope project settings
 .ropeproject
 
-# Sublime Text Settings
+# Sublime Text settings
 *.sublime-*
 
+# Jetbrain editor settings
+.idea/
+
 # Docker files
 Dockerfile
-docker-compose.yml
+docker-compose.yml

axelrod/fingerprint.py

@@ -91,16 +91,16 @@ def create_jossann(point, probe):
         x, y = point
 
         if isinstance(probe, axl.Player):
-            init_args = probe.init_args
+            init_kwargs = probe.init_kwargs
             probe = probe.__class__
         else:
-            init_args = ()
+            init_kwargs = {}
 
         if x + y >= 1:
             joss_ann = DualTransformer()(
-                JossAnnTransformer((1 - x, 1 - y))(probe))(*init_args)
+                JossAnnTransformer((1 - x, 1 - y))(probe))(**init_kwargs)
         else:
-            joss_ann = JossAnnTransformer((x, y))(probe)(*init_args)
+            joss_ann = JossAnnTransformer((x, y))(probe)(**init_kwargs)
         return joss_ann
 
     @staticmethod

axelrod/player.py

@@ -2,6 +2,7 @@
 from functools import wraps
 import random
 import copy
+import inspect
 
 from axelrod.actions import Actions, flip_action, Action
 from .game import DefaultGame
@@ -73,7 +74,7 @@ class Player(object):
     """
 
     name = "Player"
-    classifier = {} # type: Dict[str, Any]
+    classifier = {}  # type: Dict[str, Any]
     default_classifier = {
         'stochastic': False,
         'memory_depth': float('inf'),
@@ -87,10 +88,27 @@ class Player(object):
     def __new__(cls, *args, **kwargs):
         """Caches arguments for Player cloning."""
         obj = super().__new__(cls)
-        obj.init_args = args
-        obj.init_kwargs = kwargs
+        obj.init_kwargs = cls.init_params(*args, **kwargs)
         return obj
 
+    @classmethod
+    def init_params(cls, *args, **kwargs):
+        """
+        Return a dictionary containing the init parameters of a strategy (without 'self').
+        Use *args and *kwargs as value if specified
+        and complete the rest with the default values.
+        """
+        sig = inspect.signature(cls.__init__)
+        # the 'self' parameter needs to be removed or the first *args will be assigned to it
+        self_param = sig.parameters.get('self', None)
+        if self_param is not None:
+            new_params = list(sig.parameters.values())
+            new_params.remove(self_param)
+            sig = sig.replace(parameters=new_params)
+        boundargs = sig.bind_partial(*args, **kwargs)
+        boundargs.apply_defaults()
+        return boundargs.arguments
+
     def __init__(self):
         """Initiates an empty history and 0 score for a player."""
         self.history = []
@@ -122,8 +140,15 @@ def set_match_attributes(self, length=-1, game=None, noise=0):
         self.receive_match_attributes()
 
     def __repr__(self):
-        """The string method for the strategy."""
-        return self.name
+        """The string method for the strategy.
+        Appends the `__init__` parameters to the strategy's name."""
+        name = self.name
+        prefix = ': '
+        gen = (value for value in self.init_kwargs.values() if value is not None)
+        for value in gen:
+            name = ''.join([name, prefix, str(value if not isinstance(value, float) else round(value, 2))])
+            prefix = ', '
+        return name
 
     @staticmethod
     def _add_noise(noise, s1, s2):
@@ -158,7 +183,7 @@ def clone(self):
         # be significant changes required throughout the library.
         # Override in special cases only if absolutely necessary
         cls = self.__class__
-        new_player = cls(*self.init_args, **self.init_kwargs)
+        new_player = cls(**self.init_kwargs)
         new_player.match_attributes = copy.copy(self.match_attributes)
         return new_player
 

axelrod/strategies/axelrod_first.py

@@ -259,9 +259,6 @@ def __init__(self, p: float = 0.9) -> None:
         self.p = p
         super().__init__(four_vector)
 
-    def __repr__(self) -> str:
-        return "%s: %s" % (self.name, round(self.p, 2))
-
 
 class Nydegger(Player):
     """

axelrod/strategies/cycler.py

@@ -79,7 +79,6 @@ def __init__(self, cycle: str = "CCD") -> None:
         super().__init__()
         self.cycle_str = cycle
         self.cycle = self.get_new_itertools_cycle()
-        self.name = "Cycler {}".format(cycle)
         self.classifier['memory_depth'] = len(cycle) - 1
 
     def get_new_itertools_cycle(self):
@@ -99,8 +98,8 @@ class CyclerDC(Cycler):
     classifier = copy.copy(Cycler.classifier)
     classifier['memory_depth'] = 1
 
-    def __init__(self, cycle="DC") -> None:
-        super().__init__(cycle=cycle)
+    def __init__(self) -> None:
+        super().__init__(cycle="DC")
 
 
 class CyclerCCD(Cycler):
@@ -109,8 +108,8 @@ class CyclerCCD(Cycler):
     classifier = copy.copy(Cycler.classifier)
     classifier['memory_depth'] = 2
 
-    def __init__(self, cycle="CCD") -> None:
-        super().__init__(cycle=cycle)
+    def __init__(self) -> None:
+        super().__init__(cycle="CCD")
 
 
 class CyclerDDC(Cycler):
@@ -119,8 +118,8 @@ class CyclerDDC(Cycler):
     classifier = copy.copy(Cycler.classifier)
     classifier['memory_depth'] = 2
 
-    def __init__(self, cycle="DDC") -> None:
-        super().__init__(cycle=cycle)
+    def __init__(self) -> None:
+        super().__init__(cycle="DDC")
 
 
 class CyclerCCCD(Cycler):
@@ -129,8 +128,8 @@ class CyclerCCCD(Cycler):
     classifier = copy.copy(Cycler.classifier)
     classifier['memory_depth'] = 3
 
-    def __init__(self, cycle="CCCD") -> None:
-        super().__init__(cycle=cycle)
+    def __init__(self) -> None:
+        super().__init__(cycle="CCCD")
 
 
 class CyclerCCCCCD(Cycler):
@@ -139,8 +138,8 @@ class CyclerCCCCCD(Cycler):
     classifier = copy.copy(Cycler.classifier)
     classifier['memory_depth'] = 5
 
-    def __init__(self, cycle="CCCCCD") -> None:
-        super().__init__(cycle=cycle)
+    def __init__(self) -> None:
+        super().__init__(cycle="CCCCCD")
 
 
 class CyclerCCCDCD(Cycler):
@@ -149,5 +148,5 @@ class CyclerCCCDCD(Cycler):
     classifier = copy.copy(Cycler.classifier)
     classifier['memory_depth'] = 5
 
-    def __init__(self, cycle="CCCDCD") -> None:
-        super().__init__(cycle=cycle)
+    def __init__(self) -> None:
+        super().__init__(cycle="CCCDCD")

axelrod/strategies/gobymajority.py

@@ -51,14 +51,16 @@ def __init__(self, memory_depth: int = float('inf'), soft: bool = True) -> None:
             self.memory = self.classifier['memory_depth']
         else:
             self.memory = 0
-
         self.name = (
             'Go By Majority' + (self.memory > 0) * (": %i" % self.memory))
         if self.soft:
             self.name = "Soft " + self.name
         else:
             self.name = "Hard " + self.name
 
+    def __repr__(self):
+        return self.name
+
     def strategy(self, opponent: Player) -> Action:
         """This is affected by the history of the opponent.
 

axelrod/strategies/meta.py

@@ -56,6 +56,10 @@ def __init__(self, team=None):
         for t in self.team:
             self.classifier['makes_use_of'].update(t.classifier['makes_use_of'])
 
+    def __repr__(self):
+        team_size = len(self.team)
+        return '{}: {} player{}'.format(self.name, team_size, 's' if team_size > 1 else '')
+
     def strategy(self, opponent):
         # Get the results of all our players.
         results = []
@@ -148,7 +152,6 @@ def reset(self):
 
 
 NiceMetaWinner = NiceTransformer()(MetaWinner)
-NiceMetaWinner.name = "Nice Meta Winner"
 
 
 class MetaWinnerEnsemble(MetaWinner):
@@ -175,7 +178,6 @@ def meta_strategy(self, results, opponent):
 
 
 NiceMetaWinnerEnsemble = NiceTransformer()(MetaWinnerEnsemble)
-NiceMetaWinnerEnsemble.name = "Nice Meta Winner Ensemble"
 
 
 class MetaHunter(MetaPlayer):

axelrod/strategies/negation.py

@@ -8,7 +8,7 @@
 class Negation(Player):
     """
     A player starts by cooperating or defecting randomly if it's their first move,
-     then simply doing the opposite of the opponents last move thereafter.
+    then simply doing the opposite of the opponents last move thereafter.
 
     Names:
 

axelrod/strategies/prober.py

@@ -281,9 +281,6 @@ def strategy(self, opponent: Player) -> Action:
         choice = random_choice(1 - self.p)
         return choice
 
-    def __repr__(self) -> str:
-        return "%s: %s" % (self.name, round(self.p, 2))
-
 
 class RemorsefulProber(NaiveProber):
     """

axelrod/strategies/rand.py

@@ -42,6 +42,3 @@ def __init__(self, p: float=0.5) -> None:
 
     def strategy(self, opponent: Player) -> Action:
         return random_choice(self.p)
-
-    def __repr__(self) -> str:
-        return "%s: %s" % (self.name, round(self.p, 2))

axelrod/strategies/retaliate.py

@@ -34,9 +34,6 @@ def __init__(self, retaliation_threshold: float = 0.1) -> None:
         """
         super().__init__()
         self.retaliation_threshold = retaliation_threshold
-        self.name = (
-            'Retaliate (' +
-            str(self.retaliation_threshold) + ')')
         self.play_counts = defaultdict(int) # type: defaultdict
 
     def strategy(self, opponent: Player) -> Action:
@@ -130,11 +127,6 @@ def __init__(self, retaliation_threshold: float = 0.1, retaliation_limit: int =
         self.retaliation_limit = retaliation_limit
         self.play_counts = defaultdict(int) # type: defaultdict
 
-        self.name = (
-            'Limited Retaliate (' +
-            str(self.retaliation_threshold) +
-            '/' + str(self.retaliation_limit) + ')')
-
     def strategy(self, opponent: Player) -> Action:
         """
         If the opponent has played D to my C more often than x% of the time

axelrod/strategies/titfortat.py

@@ -552,10 +552,6 @@ def reset(self):
         self.world = 0.5
         self.rate = self.starting_rate
 
-    def __repr__(self) -> str:
-
-        return "%s: %s" % (self.name, round(self.rate, 2))
-
 
 class SpitefulTitForTat(Player):
     """

axelrod/strategy_transformers.py

@@ -99,23 +99,42 @@ def strategy(self, opponent):
                 return strategy_wrapper(self, opponent, proposed_action,
                                         *args, **kwargs)
 
-            # Define a new class and wrap the strategy method
             # Modify the PlayerClass name
             new_class_name = PlayerClass.__name__
             name = PlayerClass.name
             name_prefix = self.name_prefix
             if name_prefix:
                 # Modify the Player name (class variable inherited from Player)
-                new_class_name = name_prefix + PlayerClass.__name__
+                new_class_name = ''.join([name_prefix, PlayerClass.__name__])
                 # Modify the Player name (class variable inherited from Player)
-                name = name_prefix + ' ' + PlayerClass.name
+                name = ' '.join([name_prefix, PlayerClass.name])
+
+            # Define the new __repr__ method to add the wrapper arguments
+            # at the end of the name
+            def __repr__(self):
+                name = PlayerClass.__repr__(self)
+                # add eventual transformers' arguments in name
+                prefix = ': '
+                for arg in args:
+                    try:
+                        arg = [player.name for player in arg]
+                    except TypeError:
+                        pass
+                    except AttributeError:
+                        pass
+                    name = ''.join([name, prefix, str(arg)])
+                    prefix = ', '
+                return name
+
+            # Define a new class and wrap the strategy method
             # Dynamically create the new class
             new_class = type(
                 new_class_name, (PlayerClass,),
                 {
                     "name": name,
                     "original_class": PlayerClass,
                     "strategy": strategy,
+                    "__repr__": __repr__,
                     "__module__": PlayerClass.__module__,
                 })
             return new_class
@@ -193,8 +212,7 @@ def dual_wrapper(player, opponent, proposed_action):
     action: an axelrod.Action, C or D
     """
     if not player.history:
-        player.original_player = player.original_class(*player.init_args,
-                                                       **player.init_kwargs)
+        player.original_player = player.original_class(**player.init_kwargs)
 
     action = player.original_player.strategy(opponent)
     player.original_player.history.append(action)

axelrod/tests/strategies/test_axelrod_first.py

@@ -10,7 +10,7 @@
 
 class TestDavis(TestPlayer):
 
-    name = "Davis"
+    name = "Davis: 10"
     player = axelrod.Davis
     expected_classifier = {
         'memory_depth': float('inf'),
@@ -45,10 +45,9 @@ def test_strategy(self):
         self.versus_test(opponent, expected_actions=actions)
 
 
-
 class TestRevisedDowning(TestPlayer):
 
-    name = "Revised Downing"
+    name = "Revised Downing: True"
     player = axelrod.RevisedDowning
     expected_classifier = {
         'memory_depth': float('inf'),
@@ -95,7 +94,7 @@ def test_not_revised(self):
 
 class TestFeld(TestPlayer):
 
-    name = "Feld"
+    name = "Feld: 1.0, 0.5, 200"
     player = axelrod.Feld
     expected_classifier = {
         'memory_depth': 200,
@@ -321,7 +320,7 @@ def test_strategy(self):
 
 class TestTullock(TestPlayer):
 
-    name = "Tullock"
+    name = "Tullock: 11"
     player = axelrod.Tullock
     expected_classifier = {
         'memory_depth': 11,