Updated classifier checker to new API

Author: gaffney2010

axelrod/classifier.py

@@ -1,5 +1,5 @@
-from typing import Any, Callable, Generic, List, Optional, Set, Text, TypeVar, \
-    Union
+from typing import Any, Callable, Generic, List, Optional, Set, Text, Type, \
+    TypeVar, Union
 
 import yaml
 
@@ -11,11 +11,11 @@
 
 
 class Classifier(Generic[T]):
-    def __init__(self, name: Text, f: Callable[[Player], T]):
+    def __init__(self, name: Text, f: Callable[[Type[Player]], T]):
         self.name = name
         self.f = f
 
-    def calc_for_player(self, player: Player) -> T:
+    def calc_for_player(self, player: Type[Player]) -> T:
         if self.name in player.classifier:
             return player.classifier[self.name]
 
@@ -45,7 +45,7 @@ def calc_for_player(self, player: Player) -> T:
 
 
 def rebuild_classifier_table(classifiers: List[Classifier],
-                             players: List[Player],
+                             players: List[Type[Player]],
                              path: Text = ALL_CLASSIFIERS_PATH) -> None:
     all_player_dicts = dict()
     for p in players:
@@ -72,16 +72,32 @@ def __new__(cls):
         return cls._instance
 
     @classmethod
-    def get(cls, classifier: Classifier, player: Player) -> Any:
+    def get(cls, classifier: Union[Classifier, Text],
+            player: Player) -> Any:
+        # Classifier may be the name or an instance.  Convert to name.
+        if not isinstance(classifier, str):
+            classifier = classifier.name
+
+        # Factory-generated players won't exist in the table.  As well, some
+        # players, like Random, may change classifiers at construction time;
+        # this get() function takes a player instance, while the saved-values
+        # are from operations on the player object itself.
+        if classifier in player.classifier:
+            return player.classifier[classifier]
+
         def return_missing() -> None:
+            """What to do with a missing entry."""
             nonlocal classifier
             nonlocal player
-            print("Classifier {} not found for {}.".format(classifier, player))
+
+            print("Classifier {} not found for {}.".format(classifier,
+                                                           player.name))
             print("Consider rebuilding classifier table.")
+            return None
 
-        if player not in cls.all_player_dicts:
+        if player.name not in cls.all_player_dicts:
             return return_missing()
-        player_classifiers = cls.all_player_dicts[player]
+        player_classifiers = cls.all_player_dicts[player.name]
 
         if classifier not in player_classifiers:
             return return_missing()

axelrod/deterministic_cache.py

@@ -16,6 +16,7 @@
 from collections import UserDict
 from typing import List, Tuple
 
+from axelrod.classifier import Classifiers
 from .action import Action
 from .player import Player
 
@@ -57,7 +58,8 @@ def _is_valid_key(key: CachePlayerKey) -> bool:
     ):
         return False
 
-    if key[0].classifier["stochastic"] or key[1].classifier["stochastic"]:
+    if Classifiers().get("stochastic", key[0]) or Classifiers().get(
+        "stochastic", key[1]):
         return False
 
     return True

axelrod/match.py

@@ -4,8 +4,8 @@
 import axelrod.interaction_utils as iu
 from axelrod import DEFAULT_TURNS
 from axelrod.action import Action
+from axelrod.classifier import Classifiers
 from axelrod.game import Game
-
 from .deterministic_cache import DeterministicCache
 
 C, D = Action.C, Action.D
@@ -14,7 +14,7 @@
 def is_stochastic(players, noise):
     """Determines if a match is stochastic -- true if there is noise or if any
     of the players involved is stochastic."""
-    return noise or any(p.classifier["stochastic"] for p in players)
+    return noise or any(Classifiers().get("stochastic", p) for p in players)
 
 
 class Match(object):
@@ -117,7 +117,8 @@ def _cache_update_required(self):
         return (
             not self.noise
             and self._cache.mutable
-            and not (any(p.classifier["stochastic"] for p in self.players))
+            and not (
+            any(Classifiers().get("stochastic", p) for p in self.players))
         )
 
     def _cached_enough_turns(self, cache_key, turns):

axelrod/player.py

@@ -7,6 +7,7 @@
 import numpy as np
 
 from axelrod.action import Action
+from axelrod.classifier import Classifiers
 from axelrod.game import DefaultGame
 from axelrod.history import History
 from axelrod.random_ import random_flip
@@ -21,11 +22,11 @@ def is_basic(s):
     """
     Defines criteria for a strategy to be considered 'basic'
     """
-    stochastic = s.classifier["stochastic"]
-    depth = s.classifier["memory_depth"]
-    inspects_source = s.classifier["inspects_source"]
-    manipulates_source = s.classifier["manipulates_source"]
-    manipulates_state = s.classifier["manipulates_state"]
+    stochastic = Classifiers().get("stochastic", s)
+    depth = Classifiers().get("depth", s)
+    inspects_source = Classifiers().get("inspects_source", s)
+    manipulates_source = Classifiers().get("manipulates_source", s)
+    manipulates_state = Classifiers().get("manipulates_state", s)
     return (
         not stochastic
         and not inspects_source
@@ -40,12 +41,10 @@ def obey_axelrod(s):
     A function to check if a strategy obeys Axelrod's original tournament
     rules.
     """
-    classifier = s.classifier
-    return not (
-        classifier["inspects_source"]
-        or classifier["manipulates_source"]
-        or classifier["manipulates_state"]
-    )
+    for c in ["inspects_source", "manipulates_source", "manipulates_state"]:
+        if Classifiers().get(c, s):
+            return False
+    return True
 
 
 def simultaneous_play(player, coplayer, noise=0):

axelrod/strategies/__init__.py

@@ -1,3 +1,4 @@
+from ..classifier import Classifiers
 from ..player import is_basic, obey_axelrod
 from ._strategies import *
 from ._filters import passes_filterset
@@ -84,10 +85,10 @@
 strategies = [s for s in all_strategies if obey_axelrod(s())]
 
 long_run_time_strategies = [
-    s for s in all_strategies if s().classifier["long_run_time"]
+    s for s in all_strategies if Classifiers().get("long_run_time", s)
 ]
 short_run_time_strategies = [
-    s for s in strategies if not s().classifier["long_run_time"]
+    s for s in strategies if not Classifiers().get("long_run_time", s)
 ]
 cheating_strategies = [s for s in all_strategies if not obey_axelrod(s())]
 

axelrod/strategies/_filters.py

@@ -1,6 +1,8 @@
 import operator
 from collections import namedtuple
 
+from axelrod.classifier import Classifiers
+
 
 def passes_operator_filter(player, classifier_key, value, operator):
     """
@@ -43,7 +45,7 @@ class ExampleStrategy(Player):
         True if the value from the strategy's classifier dictionary matches
         the value and operator passed to the function.
     """
-    classifier_value = player.classifier[classifier_key]
+    classifier_value = Classifiers().get(classifier_key, player)
     return operator(classifier_value, value)
 
 
@@ -85,7 +87,7 @@ class ExampleStrategy(Player):
     """
     result = True
     for entry in value:
-        if entry not in player.classifier[classifier_key]:
+        if entry not in Classifiers().get(classifier_key, player):
             result = False
     return result
 

axelrod/strategies/meta.py

@@ -1,13 +1,13 @@
 import random
 
+import numpy as np
+from numpy.random import choice
+
 from axelrod.action import Action
+from axelrod.classifier import Classifiers
 from axelrod.player import Player, obey_axelrod
 from axelrod.strategies import TitForTat
 from axelrod.strategy_transformers import NiceTransformer
-
-import numpy as np
-from numpy.random import choice
-
 from ._strategies import all_strategies
 from .hunter import (
     AlternatorHunter,
@@ -69,10 +69,12 @@ def __init__(self, team=None):
             "manipulates_source",
             "manipulates_state",
         ]:
-            self.classifier[key] = any(t.classifier[key] for t in self.team)
+            self.classifier[key] = any(
+                Classifiers().get(key, t) for t in self.team)
 
         for t in self.team:
-            self.classifier["makes_use_of"].update(t.classifier["makes_use_of"])
+            self.classifier["makes_use_of"].update(
+                Classifiers().get("makes_use_of", t))
 
         self._last_results = None
 
@@ -332,7 +334,8 @@ class MetaMajorityMemoryOne(MetaMajority):
     name = "Meta Majority Memory One"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier["memory_depth"] <= 1]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) <= 1]
         super().__init__(team=team)
         self.classifier["long_run_time"] = False
 
@@ -348,11 +351,8 @@ class MetaMajorityFiniteMemory(MetaMajority):
     name = "Meta Majority Finite Memory"
 
     def __init__(self):
-        team = [
-            s
-            for s in ordinary_strategies
-            if s().classifier["memory_depth"] < float("inf")
-        ]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) < float("inf")]
         super().__init__(team=team)
 
 
@@ -367,11 +367,8 @@ class MetaMajorityLongMemory(MetaMajority):
     name = "Meta Majority Long Memory"
 
     def __init__(self):
-        team = [
-            s
-            for s in ordinary_strategies
-            if s().classifier["memory_depth"] == float("inf")
-        ]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) == float("inf")]
         super().__init__(team=team)
 
 
@@ -386,7 +383,8 @@ class MetaWinnerMemoryOne(MetaWinner):
     name = "Meta Winner Memory One"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier["memory_depth"] <= 1]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) <= 1]
         super().__init__(team=team)
         self.classifier["long_run_time"] = False
 
@@ -402,11 +400,8 @@ class MetaWinnerFiniteMemory(MetaWinner):
     name = "Meta Winner Finite Memory"
 
     def __init__(self):
-        team = [
-            s
-            for s in ordinary_strategies
-            if s().classifier["memory_depth"] < float("inf")
-        ]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) < float("inf")]
         super().__init__(team=team)
 
 
@@ -421,11 +416,8 @@ class MetaWinnerLongMemory(MetaWinner):
     name = "Meta Winner Long Memory"
 
     def __init__(self):
-        team = [
-            s
-            for s in ordinary_strategies
-            if s().classifier["memory_depth"] == float("inf")
-        ]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) == float("inf")]
         super().__init__(team=team)
 
 
@@ -440,7 +432,8 @@ class MetaWinnerDeterministic(MetaWinner):
     name = "Meta Winner Deterministic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if not s().classifier["stochastic"]]
+        team = [s for s in ordinary_strategies if
+                not Classifiers().get("stochastic", s)]
         super().__init__(team=team)
         self.classifier["stochastic"] = False
 
@@ -456,7 +449,8 @@ class MetaWinnerStochastic(MetaWinner):
     name = "Meta Winner Stochastic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier["stochastic"]]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("stochastic", s)]
         super().__init__(team=team)
 
 
@@ -512,7 +506,8 @@ class NMWEDeterministic(NiceMetaWinnerEnsemble):
     name = "NMWE Deterministic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if not s().classifier["stochastic"]]
+        team = [s for s in ordinary_strategies if
+                not Classifiers().get("stochastic", s)]
         super().__init__(team=team)
         self.classifier["stochastic"] = True
 
@@ -528,7 +523,8 @@ class NMWEStochastic(NiceMetaWinnerEnsemble):
     name = "NMWE Stochastic"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier["stochastic"]]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("stochastic", s)]
         super().__init__(team=team)
 
 
@@ -543,11 +539,8 @@ class NMWEFiniteMemory(NiceMetaWinnerEnsemble):
     name = "NMWE Finite Memory"
 
     def __init__(self):
-        team = [
-            s
-            for s in ordinary_strategies
-            if s().classifier["memory_depth"] < float("inf")
-        ]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) < float("inf")]
         super().__init__(team=team)
 
 
@@ -562,11 +555,8 @@ class NMWELongMemory(NiceMetaWinnerEnsemble):
     name = "NMWE Long Memory"
 
     def __init__(self):
-        team = [
-            s
-            for s in ordinary_strategies
-            if s().classifier["memory_depth"] == float("inf")
-        ]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) == float("inf")]
         super().__init__(team=team)
 
 
@@ -581,7 +571,8 @@ class NMWEMemoryOne(NiceMetaWinnerEnsemble):
     name = "NMWE Memory One"
 
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier["memory_depth"] <= 1]
+        team = [s for s in ordinary_strategies if
+                Classifiers().get("memory_depth", s) <= 1]
         super().__init__(team=team)
         self.classifier["long_run_time"] = False
 
@@ -627,7 +618,6 @@ def __init__(
         start_strategy_duration: int = 15,
     ):
         super().__init__(team=[start_strategy])
-        self.classifier["stochastic"] = True
         self.p_memory_delete = p_memory_delete
         self.p_memory_alter = p_memory_alter
         self.loss_value = loss_value