Silence warnings on test, and pass instances elsewhere

Author: gaffney2010

axelrod/__init__.py

@@ -1,9 +1,5 @@
 DEFAULT_TURNS = 200
 
-# We allow behavior at initialization that we don't want users to do.
-import warnings
-warnings.simplefilter('ignore', category=UserWarning)
-
 # The order of imports matters!
 from axelrod.version import __version__
 from axelrod.load_data_ import load_pso_tables, load_weights
@@ -26,5 +22,3 @@
 from axelrod.result_set import ResultSet
 from axelrod.ecosystem import Ecosystem
 from axelrod.fingerprint import AshlockFingerprint, TransitiveFingerprint
-
-warnings.simplefilter('default', category=UserWarning)

axelrod/strategies/__init__.py

@@ -80,16 +80,16 @@
     FirstByAnonymous,
     Random,
 ]
-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)]
+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)
+    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)
+    s for s in strategies if not Classifiers["long_run_time"](s())
 ]
-cheating_strategies = [s for s in all_strategies if not Classifiers.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

@@ -20,7 +20,7 @@
 )
 
 # 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
 
@@ -332,7 +332,7 @@ 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
 
@@ -351,7 +351,7 @@ def __init__(self):
         team = [
             s
             for s in ordinary_strategies
-            if Classifiers["memory_depth"](s) < float("inf")
+            if Classifiers["memory_depth"](s()) < float("inf")
         ]
         super().__init__(team=team)
 
@@ -370,7 +370,7 @@ def __init__(self):
         team = [
             s
             for s in ordinary_strategies
-            if Classifiers["memory_depth"](s) == float("inf")
+            if Classifiers["memory_depth"](s()) == float("inf")
         ]
         super().__init__(team=team)
 
@@ -386,7 +386,7 @@ 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
 
@@ -405,7 +405,7 @@ def __init__(self):
         team = [
             s
             for s in ordinary_strategies
-            if Classifiers["memory_depth"](s) < float("inf")
+            if Classifiers["memory_depth"](s()) < float("inf")
         ]
         super().__init__(team=team)
 
@@ -424,7 +424,7 @@ def __init__(self):
         team = [
             s
             for s in ordinary_strategies
-            if Classifiers["memory_depth"](s) == float("inf")
+            if Classifiers["memory_depth"](s()) == float("inf")
         ]
         super().__init__(team=team)
 
@@ -440,7 +440,7 @@ 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
 
@@ -456,7 +456,7 @@ 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)
 
 
@@ -512,7 +512,7 @@ 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
 
@@ -528,7 +528,7 @@ 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)
 
 
@@ -546,7 +546,7 @@ def __init__(self):
         team = [
             s
             for s in ordinary_strategies
-            if Classifiers["memory_depth"](s) < float("inf")
+            if Classifiers["memory_depth"](s()) < float("inf")
         ]
         super().__init__(team=team)
 
@@ -565,7 +565,7 @@ def __init__(self):
         team = [
             s
             for s in ordinary_strategies
-            if Classifiers["memory_depth"](s) == float("inf")
+            if Classifiers["memory_depth"](s()) == float("inf")
         ]
         super().__init__(team=team)
 
@@ -581,7 +581,7 @@ 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/tests/integration/test_filtering.py

@@ -1,4 +1,5 @@
 import unittest
+import warnings
 
 from hypothesis import example, given, settings
 from hypothesis.strategies import integers
@@ -13,6 +14,9 @@ class TestFiltersAgainstComprehensions(unittest.TestCase):
     Test that the results of filtering strategies via a filterset dict
     match the results from using a list comprehension.
     """
+    def setUp(self) -> None:
+        # Ignore warnings about classifiers running on instances
+        warnings.simplefilter("ignore", category=UserWarning)
 
     @given(strategies=strategy_lists(min_size=20, max_size=20))
     def test_boolean_filtering(self, strategies):

axelrod/tests/integration/test_matches.py

@@ -11,10 +11,10 @@
 C, D = axelrod.Action.C, axelrod.Action.D
 
 deterministic_strategies = [
-    s for s in axelrod.short_run_time_strategies if not Classifiers["stochastic"](s)
+    s for s in axelrod.short_run_time_strategies if not Classifiers["stochastic"](s())
 ]
 stochastic_strategies = [
-    s for s in axelrod.short_run_time_strategies if Classifiers["stochastic"](s)
+    s for s in axelrod.short_run_time_strategies if Classifiers["stochastic"](s())
 ]
 
 

axelrod/tests/integration/test_tournament.py

@@ -82,7 +82,7 @@ def test_repeat_tournament_deterministic(self):
         deterministic_players = [
             s()
             for s in axelrod.short_run_time_strategies
-            if not Classifiers["stochastic"](s)
+            if not Classifiers["stochastic"](s())
         ]
         files = []
         for _ in range(2):
@@ -105,7 +105,7 @@ def test_repeat_tournament_stochastic(self):
         for _ in range(2):
             axelrod.seed(0)
             stochastic_players = [s() for s in axelrod.short_run_time_strategies
-                                  if Classifiers["stochastic"](s)]
+                                  if Classifiers["stochastic"](s())]
             tournament = axelrod.Tournament(
                 name="test",
                 players=stochastic_players,

axelrod/tests/strategies/test_player.py

@@ -17,7 +17,7 @@
 C, D = axelrod.Action.C, axelrod.Action.D
 
 short_run_time_short_mem = [
-    s for s in axelrod.short_run_time_strategies if Classifiers["memory_depth"](s) <= 10
+    s for s in axelrod.short_run_time_strategies if Classifiers["memory_depth"](s()) <= 10
 ]
 
 

axelrod/tests/strategies/test_titfortat.py

@@ -708,7 +708,7 @@ class TestContriteTitForTat(TestPlayer):
     }
 
     deterministic_strategies = [
-        s for s in axelrod.strategies if not Classifiers["stochastic"](s)
+        s for s in axelrod.strategies if not Classifiers["stochastic"](s())
     ]
 
     def test_init(self):

axelrod/tests/unit/test_property.py

@@ -15,7 +15,7 @@
 )
 
 stochastic_strategies = [
-    s for s in axelrod.strategies if Classifiers["stochastic"](s)
+    s for s in axelrod.strategies if Classifiers["stochastic"](s())
 ]
 
 

axelrod/tests/unit/test_strategy_transformers.py

@@ -314,27 +314,27 @@ def test_jossann_transformer(self):
 
         probability = (0, 1)
         p1 = JossAnnTransformer(probability)(axelrod.Random)
-        self.assertFalse(Classifiers["stochastic"](p1))
+        self.assertFalse(Classifiers["stochastic"](p1()))
 
         probability = (1, 0)
         p1 = JossAnnTransformer(probability)(axelrod.Random)
-        self.assertFalse(Classifiers["stochastic"](p1))
+        self.assertFalse(Classifiers["stochastic"](p1()))
 
         probability = (0.5, 0.5)
         p1 = JossAnnTransformer(probability)(axelrod.TitForTat)
-        self.assertTrue(Classifiers["stochastic"](p1))
+        self.assertTrue(Classifiers["stochastic"](p1()))
 
         probability = (0, 0.5)
         p1 = JossAnnTransformer(probability)(axelrod.TitForTat)
-        self.assertTrue(Classifiers["stochastic"](p1))
+        self.assertTrue(Classifiers["stochastic"](p1()))
 
         probability = (0, 0)
         p1 = JossAnnTransformer(probability)(axelrod.TitForTat)
-        self.assertFalse(Classifiers["stochastic"](p1))
+        self.assertFalse(Classifiers["stochastic"](p1()))
 
         probability = (0, 0)
         p1 = JossAnnTransformer(probability)(axelrod.Random)
-        self.assertTrue(Classifiers["stochastic"](p1))
+        self.assertTrue(Classifiers["stochastic"](p1()))
 
     def test_noisy_transformer(self):
         """Tests that the noisy transformed does flip some moves."""
@@ -348,19 +348,19 @@ def test_noisy_transformer(self):
         self.assertEqual(p2.history, [C, C, C, C, C, C, D, D, C, C])
 
         p2 = NoisyTransformer(0)(axelrod.Cooperator)
-        self.assertFalse(Classifiers["stochastic"](p2))
+        self.assertFalse(Classifiers["stochastic"](p2()))
 
         p2 = NoisyTransformer(1)(axelrod.Cooperator)
-        self.assertFalse(Classifiers["stochastic"](p2))
+        self.assertFalse(Classifiers["stochastic"](p2()))
 
         p2 = NoisyTransformer(0.3)(axelrod.Cooperator)
-        self.assertTrue(Classifiers["stochastic"](p2))
+        self.assertTrue(Classifiers["stochastic"](p2()))
 
         p2 = NoisyTransformer(0)(axelrod.Random)
-        self.assertTrue(Classifiers["stochastic"](p2))
+        self.assertTrue(Classifiers["stochastic"](p2()))
 
         p2 = NoisyTransformer(1)(axelrod.Random)
-        self.assertTrue(Classifiers["stochastic"](p2))
+        self.assertTrue(Classifiers["stochastic"](p2()))
 
     def test_forgiving(self):
         """Tests that the forgiving transformer flips some defections."""
@@ -525,7 +525,7 @@ def test_mixed(self):
         """Tests the MixedTransformer."""
         probability = 1
         MD = MixedTransformer(probability, axelrod.Cooperator)(axelrod.Defector)
-        self.assertFalse(Classifiers["stochastic"](MD))
+        self.assertFalse(Classifiers["stochastic"](MD()))
 
         p1 = MD()
         p2 = axelrod.Cooperator()
@@ -535,7 +535,7 @@ def test_mixed(self):
 
         probability = 0
         MD = MixedTransformer(probability, axelrod.Cooperator)(axelrod.Defector)
-        self.assertFalse(Classifiers["stochastic"](MD))
+        self.assertFalse(Classifiers["stochastic"](MD()))
 
         p1 = MD()
         p2 = axelrod.Cooperator()
@@ -549,7 +549,7 @@ def test_mixed(self):
         probability = [0.3, 0.2, 0]
         strategies = [axelrod.TitForTat, axelrod.Grudger, axelrod.Defector]
         MD = MixedTransformer(probability, strategies)(axelrod.Cooperator)
-        self.assertTrue(Classifiers["stochastic"](MD))
+        self.assertTrue(Classifiers["stochastic"](MD()))
 
         p1 = MD()
         # Against a cooperator we see that we only cooperate
@@ -562,7 +562,7 @@ def test_mixed(self):
         probability = (0, 0, 1)  # Note can also pass tuple
         strategies = [axelrod.TitForTat, axelrod.Grudger, axelrod.Defector]
         MD = MixedTransformer(probability, strategies)(axelrod.Cooperator)
-        self.assertFalse(Classifiers["stochastic"](MD))
+        self.assertFalse(Classifiers["stochastic"](MD()))
 
         p1 = MD()
         # Against a cooperator we see that we only defect