Move is_basic and obey_axelrod to Classifiers class.

Author: gaffney2010

axelrod/__init__.py

@@ -10,7 +10,7 @@
 from axelrod.game import DefaultGame, Game
 from axelrod.history import History, LimitedHistory
 from axelrod.player import Player
-from axelrod.classifier import Classifiers, is_basic, obey_axelrod
+from axelrod.classifier import Classifiers
 from axelrod.evolvable_player import EvolvablePlayer
 from axelrod.mock_player import MockPlayer
 from axelrod.match import Match

axelrod/classifier.py

@@ -203,37 +203,34 @@ def classify_player_for_this_classifier(
 
         return classify_player_for_this_classifier
 
+    @classmethod
+    def is_basic(cls, s: Union[Player, Type[Player]]):
+        """
+        Defines criteria for a strategy to be considered 'basic'
+        """
+        stochastic = cls.__getitem__("stochastic")(s)
+        depth = cls.__getitem__("memory_depth")(s)
+        inspects_source = cls.__getitem__("inspects_source")(s)
+        manipulates_source = cls.__getitem__("manipulates_source")(s)
+        manipulates_state = cls.__getitem__("manipulates_state")(s)
+        return (
+            not stochastic
+            and not inspects_source
+            and not manipulates_source
+            and not manipulates_state
+            and depth in (0, 1)
+        )
 
-Classifiers = _Classifiers()
-
-
-# Strategy classifiers
+    @classmethod
+    def obey_axelrod(cls, s: Union[Player, Type[Player]]):
+        """
+        A function to check if a strategy obeys Axelrod's original tournament
+        rules.
+        """
+        for c in ["inspects_source", "manipulates_source", "manipulates_state"]:
+            if cls.__getitem__(c)(s):
+                return False
+        return True
 
 
-def is_basic(s):
-    """
-    Defines criteria for a strategy to be considered 'basic'
-    """
-    stochastic = Classifiers["stochastic"](s)
-    depth = Classifiers["memory_depth"](s)
-    inspects_source = Classifiers["inspects_source"](s)
-    manipulates_source = Classifiers["manipulates_source"](s)
-    manipulates_state = Classifiers["manipulates_state"](s)
-    return (
-        not stochastic
-        and not inspects_source
-        and not manipulates_source
-        and not manipulates_state
-        and depth in (0, 1)
-    )
-
-
-def obey_axelrod(s):
-    """
-    A function to check if a strategy obeys Axelrod's original tournament
-    rules.
-    """
-    for c in ["inspects_source", "manipulates_source", "manipulates_state"]:
-        if Classifiers[c](s):
-            return False
-    return True
+Classifiers = _Classifiers()

axelrod/strategies/__init__.py

@@ -1,4 +1,4 @@
-from ..classifier import Classifiers, is_basic, obey_axelrod
+from ..classifier import Classifiers
 from ._strategies import *
 from ._filters import passes_filterset
 
@@ -80,16 +80,16 @@
     FirstByAnonymous,
     Random,
 ]
-basic_strategies = [s for s in all_strategies if is_basic(s())]
-strategies = [s for s in all_strategies if obey_axelrod(s())]
+basic_strategies = [s for s in all_strategies if Classifiers.is_basic(s)]
+strategies = [s for s in all_strategies if Classifiers.obey_axelrod(s)]
 
 long_run_time_strategies = [
     s for s in all_strategies if Classifiers["long_run_time"](s)
 ]
 short_run_time_strategies = [
     s for s in strategies if not Classifiers["long_run_time"](s)
 ]
-cheating_strategies = [s for s in all_strategies if not obey_axelrod(s())]
+cheating_strategies = [s for s in all_strategies if not Classifiers.obey_axelrod(s)]
 
 ordinary_strategies = strategies  # This is a legacy and will be removed
 

axelrod/strategies/meta.py

@@ -4,7 +4,7 @@
 from numpy.random import choice
 
 from axelrod.action import Action
-from axelrod.classifier import Classifiers, obey_axelrod
+from axelrod.classifier import Classifiers
 from axelrod.player import Player
 from axelrod.strategies import TitForTat
 from axelrod.strategy_transformers import NiceTransformer
@@ -20,7 +20,7 @@
 )
 
 # Needs to be computed manually to prevent circular dependency
-ordinary_strategies = [s for s in all_strategies if obey_axelrod(s)]
+ordinary_strategies = [s for s in all_strategies if Classifiers.obey_axelrod(s)]
 
 C, D = Action.C, Action.D
 

axelrod/tests/unit/test_classification.py

@@ -151,13 +151,13 @@ def test_obey_axelrod(self):
         ]
 
         for strategy in known_cheaters:
-            self.assertFalse(axl.obey_axelrod(strategy()), msg=strategy)
+            self.assertFalse(axl.Classifiers.obey_axelrod(strategy), msg=strategy)
 
         for strategy in known_basic:
-            self.assertTrue(axl.obey_axelrod(strategy()), msg=strategy)
+            self.assertTrue(axl.Classifiers.obey_axelrod(strategy), msg=strategy)
 
         for strategy in known_ordinary:
-            self.assertTrue(axl.obey_axelrod(strategy()), msg=strategy)
+            self.assertTrue(axl.Classifiers.obey_axelrod(strategy), msg=strategy)
 
     def test_is_basic(self):
         """A test that verifies if the is_basic function works correctly"""
@@ -193,13 +193,13 @@ def test_is_basic(self):
         ]
 
         for strategy in known_cheaters:
-            self.assertFalse(axl.is_basic(strategy()), msg=strategy)
+            self.assertFalse(axl.Classifiers.is_basic(strategy), msg=strategy)
 
         for strategy in known_basic:
-            self.assertTrue(axl.is_basic(strategy()), msg=strategy)
+            self.assertTrue(axl.Classifiers.is_basic(strategy), msg=strategy)
 
         for strategy in known_ordinary:
-            self.assertFalse(axl.is_basic(strategy()), msg=strategy)
+            self.assertFalse(axl.Classifiers.is_basic(strategy), msg=strategy)
 
 
 def str_reps(xs):

docs/tutorials/advanced/classification_of_strategies.rst

@@ -114,12 +114,12 @@ Some strategies have been classified as having a particularly long run time::
     18
 
 Strategies that :code:`manipulate_source`, :code:`manipulate_state`
-and/or :code:`inspect_source` return :code:`False` for the :code:`obey_axelrod`
-function::
+and/or :code:`inspect_source` return :code:`False` for the
+:code:`Classifier.obey_axelrod` function::
 
     >>> s = axl.MindBender()
-    >>> axl.obey_axelrod(s)
+    >>> axl.Classifier.obey_axelrod(s)
     False
     >>> s = axl.TitForTat()
-    >>> axl.obey_axelrod(s)
+    >>> axl.Classifier.obey_axelrod(s)
     True