before change to decorator __reduce__

Author: eric-s-s

axelrod/strategy_transformers.py

@@ -13,8 +13,6 @@
 from .action import Action
 from .random_ import random_choice
 from importlib import import_module
-from pydoc import locate
-import axelrod
 
 
 C, D = Action.C, Action.D
@@ -61,6 +59,7 @@ def __init__(self, *args, **kwargs):
                 self.name_prefix = name_prefix
 
         def __reduce__(self):
+            # Creates only the Decorator class and not the instance
             return StrategyTransformerFactory, (
                 strategy_wrapper, name_prefix, reclassifier)
 
@@ -91,26 +90,18 @@ def __call__(self, PlayerClass):
             except KeyError:
                 pass
 
-            # Is the original strategy method a static method?
-            # signature = inspect.signature(PlayerClass.strategy)
-            # strategy_args = [p.name for p in signature.parameters.values()
-            #         if p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD]
-            # is_static = True
-            # if len(strategy_args) > 1:
-            #     is_static = False
-
             # Define the new strategy method, wrapping the existing method
             # with `strategy_wrapper`
             def strategy(self, opponent):
-                if strategy_wrapper != dual_wrapper:
+                if strategy_wrapper == dual_wrapper:
+                    # Dummy Action for dual_wrapper.
+                    # This is to avoid calling the strategy twice.
+                    proposed_action = C
+                else:
                     if is_strategy_static(PlayerClass):
-                        # static method
                         proposed_action = PlayerClass.strategy(opponent)
                     else:
                         proposed_action = PlayerClass.strategy(self, opponent)
-                else:
-                    # dummy Action for dual_wrapper to avoid calling class
-                    proposed_action = C
 
                 # Apply the wrapper
                 return strategy_wrapper(self, opponent, proposed_action,
@@ -151,7 +142,7 @@ def __repr__(self):
                     prefix = ', '
                 return name
 
-            def new_class_reduce(self_):
+            def reduce_for_decorated_class(self_):
                 class_module = import_module(self_.__module__)
                 import_name = self_.__class__.__name__
                 if import_name in dir(class_module):
@@ -167,7 +158,7 @@ def new_class_reduce(self_):
                             break
 
                     return (
-                        NewRecon(),
+                        ReConstructor(),
                         (decorators, import_name, self_.__module__),
                         self_.__dict__
                     )
@@ -185,14 +176,14 @@ def new_class_reduce(self_):
                     "__module__": PlayerClass.__module__,
                     "classifier": classifier,
                     "__doc__": PlayerClass.__doc__,
-                    "__reduce__": new_class_reduce,
+                    "__reduce__": reduce_for_decorated_class,
                 })
 
             return new_class
     return Decorator
 
 
-class NewRecon(object):
+class ReConstructor(object):
     def __init__(self):
         pass
 
@@ -209,20 +200,6 @@ def __call__(self, decorators, import_name, module_name):
             return generated_class()
 
 
-# class Reconstitutor(object):
-#     def __init__(self):
-#
-#         pass
-#
-#     def __call__(self, decorators, player_class, original_name):
-#         use_class = player_class
-#
-#         for decorator, args, kwargs in decorators:
-#             use_class = decorator(*args, **kwargs)(use_class)
-#         obj = use_class()
-#         obj.__class__.__name__ = original_name
-#         return obj
-
 def compose_transformers(t1, t2):
     """Compose transformers without having to invoke the first on
     a PlayerClass."""

axelrod/tests/unit/test_pickling.py

@@ -144,26 +144,31 @@ def test_pointer_to_class_derived_from_Player(self):
         )
 
         self.assert_original_plays_same_as_pickled(player, turns=10)
-
         self.assert_instance_with_history_equality(player)
 
     def test_regression_dual_transformer_with_lookerup(self):
-        player = DualTransformer()(LookerUp)()
-        self.assert_instance_with_history_equality(player)
+        self.assert_dual_wrapper_correct(axl.LookerUp)
+        self.assert_dual_wrapper_correct(axl.EvolvedLookerUp2_2_2)
+
+    def test_regression_dual_transformer_with_fsm(self):
+        self.assert_dual_wrapper_correct(axl.Fortress3)
+        self.assert_dual_wrapper_correct(axl.Fortress4)
+
+    def assert_dual_wrapper_correct(self, player_class):
+        p1 = player_class()
+        p2 = DualTransformer()(player_class)()
+        p3 = axl.CyclerCCD()  # Cycles 'CCD'
+        for _ in range(10):
+            p1.play(p3)
+
+        p3.reset()
+
+        for _ in range(10):
+            p2.play(p3)
 
-        fp = AshlockFingerprint(axl.Cooperator, probe=LookerUp())
-        fp.fingerprint(turns=10, repetitions=2, step=0.2)
+        self.assertEqual(p1.history, [x.flip() for x in p2.history])
 
-        fp = AshlockFingerprint(EvolvedLookerUp1_1_1)
-        fp.fingerprint(turns=10, repetitions=2, step=0.2)
 
-        strategy = axl.WinStayLoseShift
-        probe = axl.TitForTat
-        af = axl.AshlockFingerprint(strategy, probe)
-        data = af.fingerprint(turns=50, repetitions=2, step=0.01)
-        # data = af.fingerprint(turns=5, repetitions=2, step=0.1)
-        p = af.plot()
-        p.savefig('omfg')