Replace makes_use_of classifier

Author: gaffney2010

axelrod/classifier.py

@@ -14,6 +14,7 @@
 import warnings
 import yaml
 
+from axelrod.makes_use_of import makes_use_of
 from axelrod.player import Player
 
 ALL_CLASSIFIERS_PATH = "data/all_classifiers.yml"
@@ -59,12 +60,18 @@ def classify_player(self, player: Type[Player]) -> T:
 
 
 stochastic = Classifier[bool]("stochastic", lambda _: False)
-memory_depth = Classifier[Union[float, int]]("memory_depth", lambda _: float("inf"))
-makes_use_of = Classifier[Optional[Set[Text]]]("makes_use_of", lambda _: None)
+memory_depth = Classifier[Union[float, int]](
+    "memory_depth", lambda _: float("inf")
+)
+makes_use_of = Classifier[Optional[Set[Text]]]("makes_use_of", makes_use_of)
 long_run_time = Classifier[bool]("long_run_time", lambda _: False)
 inspects_source = Classifier[Optional[bool]]("inspects_source", lambda _: None)
-manipulates_source = Classifier[Optional[bool]]("manipulates_source", lambda _: None)
-manipulates_state = Classifier[Optional[bool]]("manipulates_state", lambda _: None)
+manipulates_source = Classifier[Optional[bool]](
+    "manipulates_source", lambda _: None
+)
+manipulates_state = Classifier[Optional[bool]](
+    "manipulates_state", lambda _: None
+)
 
 # Should list all known classifiers.
 all_classifiers = [

axelrod/data/all_classifiers.yml

@@ -1,18 +1,24 @@
 import inspect
 import re
-from typing import Set, Text, Type
+from typing import Callable, Set, Text, Type
 
 from axelrod.player import Player
 
 
+def method_makes_use_of(method: Callable) -> Set[Text]:
+    result = set()
+    method_code = inspect.getsource(method)
+    attr_string = r".match_attributes\[\"(\w+)\"\]"
+    all_attrs = re.findall(attr_string, method_code)
+    for attr in all_attrs:
+        result.add(attr)
+    return result
+
+
 def makes_use_of(player: Type[Player]) -> Set[Text]:
     result = set()
     for method in inspect.getmembers(player, inspect.ismethod):
         if method[0] == "__init__":
             continue
-        method_code = inspect.getsource(method[1])
-        attr_string = r"self.match_attributes\[\"(\w+)\"\]"
-        all_attrs = re.findall(attr_string, method_code)
-        for attr in all_attrs:
-            result.add(attr)
+        result.update(method_makes_use_of(method[1]))
     return result

axelrod/makes_use_of.py

@@ -20,7 +20,9 @@
 )
 
 # Needs to be computed manually to prevent circular dependency
-ordinary_strategies = [s for s in all_strategies if Classifiers.obey_axelrod(s())]
+ordinary_strategies = [
+    s for s in all_strategies if Classifiers.obey_axelrod(s())
+]
 
 C, D = Action.C, Action.D
 
@@ -70,8 +72,11 @@ def __init__(self, team=None):
         ]:
             self.classifier[key] = any(map(Classifiers[key], self.team))
 
+        self.classifier["makes_use_of"] = set()
         for t in self.team:
-            self.classifier["makes_use_of"].update(Classifiers["makes_use_of"](t))
+            new_uses = Classifiers["makes_use_of"](t)
+            if new_uses:
+                self.classifier["makes_use_of"].update(new_uses)
 
         self._last_results = None
 
@@ -329,7 +334,11 @@ class MetaMajorityMemoryOne(MetaMajority):
     name = "Meta Majority Memory One"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if Classifiers["memory_depth"](s()) <= 1]
+        team = [
+            s
+            for s in ordinary_strategies
+            if Classifiers["memory_depth"](s()) <= 1
+        ]
         super().__init__(team=team)
         self.classifier["long_run_time"] = False
 
@@ -383,7 +392,11 @@ class MetaWinnerMemoryOne(MetaWinner):
     name = "Meta Winner Memory One"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if Classifiers["memory_depth"](s()) <= 1]
+        team = [
+            s
+            for s in ordinary_strategies
+            if Classifiers["memory_depth"](s()) <= 1
+        ]
         super().__init__(team=team)
         self.classifier["long_run_time"] = False
 
@@ -437,7 +450,9 @@ class MetaWinnerDeterministic(MetaWinner):
     name = "Meta Winner Deterministic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if not Classifiers["stochastic"](s())]
+        team = [
+            s for s in ordinary_strategies if not Classifiers["stochastic"](s())
+        ]
         super().__init__(team=team)
         self.classifier["stochastic"] = False
 
@@ -453,7 +468,9 @@ class MetaWinnerStochastic(MetaWinner):
     name = "Meta Winner Stochastic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if Classifiers["stochastic"](s())]
+        team = [
+            s for s in ordinary_strategies if Classifiers["stochastic"](s())
+        ]
         super().__init__(team=team)
 
 
@@ -508,7 +525,9 @@ class NMWEDeterministic(NiceMetaWinnerEnsemble):
     name = "NMWE Deterministic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if not Classifiers["stochastic"](s())]
+        team = [
+            s for s in ordinary_strategies if not Classifiers["stochastic"](s())
+        ]
         super().__init__(team=team)
         self.classifier["stochastic"] = True
 
@@ -524,7 +543,9 @@ class NMWEStochastic(NiceMetaWinnerEnsemble):
     name = "NMWE Stochastic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if Classifiers["stochastic"](s())]
+        team = [
+            s for s in ordinary_strategies if Classifiers["stochastic"](s())
+        ]
         super().__init__(team=team)
 
 
@@ -577,7 +598,11 @@ class NMWEMemoryOne(NiceMetaWinnerEnsemble):
     name = "NMWE Memory One"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if Classifiers["memory_depth"](s()) <= 1]
+        team = [
+            s
+            for s in ordinary_strategies
+            if Classifiers["memory_depth"](s()) <= 1
+        ]
         super().__init__(team=team)
         self.classifier["long_run_time"] = False
 

axelrod/strategies/meta.py

@@ -16,6 +16,7 @@
 
 from axelrod.strategies.sequence_player import SequencePlayer
 from .action import Action
+from .makes_use_of import method_makes_use_of
 from .player import Player
 from .random_ import random_choice
 
@@ -27,7 +28,9 @@
 # Alternator.
 
 
-def StrategyTransformerFactory(strategy_wrapper, name_prefix=None, reclassifier=None):
+def StrategyTransformerFactory(
+    strategy_wrapper, name_prefix=None, reclassifier=None
+):
     """Modify an existing strategy dynamically by wrapping the strategy
     method with the argument `strategy_wrapper`.
 
@@ -130,6 +133,11 @@ def strategy(self, opponent):
                 classifier = reclassifier(original_classifier, *args, **kwargs)
             else:
                 classifier = original_classifier
+            strategy_wrapper_uses = method_makes_use_of(strategy_wrapper)
+            if "makes_use_of" in classifier:
+                classifier["makes_use_of"].update(strategy_wrapper_uses)
+            elif strategy_wrapper_uses:
+                classifier["makes_use_of"] = strategy_wrapper_uses
 
             # Define the new __repr__ method to add the wrapper arguments
             # at the end of the name
@@ -232,7 +240,11 @@ class DecoratorReBuilder(object):
     """
 
     def __call__(
-        self, factory_args: tuple, args: tuple, kwargs: dict, instance_name_prefix: str
+        self,
+        factory_args: tuple,
+        args: tuple,
+        kwargs: dict,
+        instance_name_prefix: str,
     ) -> Any:
 
         decorator_class = StrategyTransformerFactory(*factory_args)
@@ -246,7 +258,9 @@ class StrategyReBuilder(object):
     that could not normally be pickled.
     """
 
-    def __call__(self, decorators: list, import_name: str, module_name: str) -> Player:
+    def __call__(
+        self, decorators: list, import_name: str, module_name: str
+    ) -> Player:
 
         module_ = import_module(module_name)
         import_class = getattr(module_, import_name)
@@ -275,7 +289,9 @@ def __call__(self, PlayerClass):
     return Composition()
 
 
-def generic_strategy_wrapper(player, opponent, proposed_action, *args, **kwargs):
+def generic_strategy_wrapper(
+    player, opponent, proposed_action, *args, **kwargs
+):
     """
     Strategy wrapper functions should be of the following form.
 
@@ -307,7 +323,9 @@ def flip_wrapper(player, opponent, action):
     return action.flip()
 
 
-FlipTransformer = StrategyTransformerFactory(flip_wrapper, name_prefix="Flipped")
+FlipTransformer = StrategyTransformerFactory(
+    flip_wrapper, name_prefix="Flipped"
+)
 
 
 def dual_wrapper(player, opponent: Player, proposed_action: Action) -> Action:
@@ -377,7 +395,9 @@ def forgiver_reclassifier(original_classifier, p):
 
 
 ForgiverTransformer = StrategyTransformerFactory(
-    forgiver_wrapper, name_prefix="Forgiving", reclassifier=forgiver_reclassifier
+    forgiver_wrapper,
+    name_prefix="Forgiving",
+    reclassifier=forgiver_reclassifier,
 )
 
 
@@ -442,7 +462,6 @@ def final_sequence(player, opponent, action, seq):
 
 def final_reclassifier(original_classifier, seq):
     """Reclassify the strategy"""
-    original_classifier["makes_use_of"].update(["length"])
     original_classifier["memory_depth"] = max(
         len(seq), original_classifier["memory_depth"]
     )
@@ -495,14 +514,18 @@ def grudge_wrapper(player, opponent, action, grudges):
     return action
 
 
-GrudgeTransformer = StrategyTransformerFactory(grudge_wrapper, name_prefix="Grudging")
+GrudgeTransformer = StrategyTransformerFactory(
+    grudge_wrapper, name_prefix="Grudging"
+)
 
 
 def apology_wrapper(player, opponent, action, myseq, opseq):
     length = len(myseq)
     if len(player.history) < length:
         return action
-    if (myseq == player.history[-length:]) and (opseq == opponent.history[-length:]):
+    if (myseq == player.history[-length:]) and (
+        opseq == opponent.history[-length:]
+    ):
         return C
     return action
 
@@ -535,9 +558,7 @@ def mixed_wrapper(player, opponent, action, probability, m_player):
         probability = [probability]
 
     # If a probability distribution, players is passed
-    if isinstance(probability, Iterable) and isinstance(
-        m_player, Iterable
-    ):
+    if isinstance(probability, Iterable) and isinstance(m_player, Iterable):
         mutate_prob = sum(probability)  # Prob of mutation
         if mutate_prob > 0:
             # Distribution of choice of mutation:

axelrod/strategy_transformers.py

@@ -0,0 +1,4 @@
+Cooperator:
+  name: Cooperator
+Defector:
+  name: Defector