tests pass. still a mess

Author: eric-s-s

axelrod/strategy_transformers.py

@@ -12,6 +12,9 @@
 from numpy.random import choice
 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
@@ -57,6 +60,10 @@ def __init__(self, *args, **kwargs):
             else:
                 self.name_prefix = name_prefix
 
+        def __reduce__(self):
+            return StrategyTransformerFactory, (
+                strategy_wrapper, name_prefix, reclassifier)
+
         def __call__(self, PlayerClass):
             """
             Parameters
@@ -144,22 +151,33 @@ def __repr__(self):
             # Define a new class and wrap the strategy method
             # Dynamically create the new class
             def reducer(self_):
-                class_module = __import__(self_.__module__)
+                class_module = import_module(self_.__module__)
                 if self_.__class__.__name__ in dir(class_module):
                     return self_.__class__, (), self_.__dict__
 
-                
                 else:
-                    print('oops {}  {}'.format(
-                        self_.__class__.__name__, self_.original_class.__name__
-                    ))
+
+                    decorators = [self_.decorator]
+                    pc = self_.original_class
+                    original_name = pc.__name__
+                    for klass in pc.mro():
+                        if hasattr(klass, 'decorator'):
+                            decorators.append(klass.decorator)
+                        if klass in axelrod.strategies:
+                            pc = klass
+                            break
+                    return (Reconstitutor(),
+                            (decorators, pc, original_name),
+                            self_.__dict__)
+
 
             new_class = type(
                 new_class_name, (PlayerClass,),
                 {
                     "name": name,
                     "original_class": PlayerClass,
                     "strategy": strategy,
+                    "decorator": (self, self.args, self.kwargs),
                     "__repr__": __repr__,
                     "__module__": PlayerClass.__module__,
                     "classifier": classifier,
@@ -169,6 +187,19 @@ def reducer(self_):
             return new_class
     return Decorator
 
+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

axelrod/my_t.py axelrod/tests/classes_for_testing_pickling.py

@@ -6,10 +6,14 @@
 
 @st.FlipTransformer()
 @st.FlipTransformer()
-class TestFlip(axl.Cooperator):
+class DoubleFlip(axl.Cooperator):
     pass
 
 
+@st.FlipTransformer()
+class SingleFlip(axl.Cooperator):
+    pass
+
 @st.ApologyTransformer([D], [C])
 class Apology(axl.Cooperator):
     pass

axelrod/test_pickling.py axelrod/tests/unit/test_pickling.py

@@ -1,9 +1,9 @@
-import unittest
 import pickle
+import unittest
+
 import axelrod as axl
 from axelrod.strategy_transformers import FlipTransformer
-from axelrod.my_t import transformed, TestFlip
-
+from axelrod.tests.classes_for_testing_pickling import transformed, DoubleFlip
 
 C, D = axl.Action.C, axl.Action.D
 
@@ -68,47 +68,23 @@ def test_all(self):
             self.assertEqual(reconstituted, player)
 
     def test_pickling_transformers(self):
-        player = transformed[0]()
-        print(player.__dict__)
-        print(player.__class__.original_class)
 
         for s in transformed:
             player = s()
             player.play(axl.Cooperator())
-            # print(player.name, player.__class__.__name__)
             reconstituted = pickle.loads(pickle.dumps(player))
-
             self.assertEqual(reconstituted, player)
 
     def test_created(self):
         x = FlipTransformer()(axl.Cooperator)
         x = FlipTransformer()(x)
         x = FlipTransformer()(x)()
-        # print(x.__reduce__())
-        # print('created')
-        # print(repr(pickle.dumps(x)))
         z = pickle.loads(pickle.dumps(x))
-        # print(z)
-        # print(z.__dict__)
+
         self.assertEqual(x, z)
 
     def test_created_two(self):
-        # print('created_two')
-        x = TestFlip()
-        # print(x.__dict__)
-        # print(x.__class__.__dict__)
-        # print(x.__class__.__name__)
-        # print(x.__dir__())
+        x = DoubleFlip()
         z = pickle.dumps(x)
         self.assertEqual(x, pickle.loads(z))
-
-    # def test_reconsitutor(self):
-    #     x = TestFlip()
-    #     print('reconstructor')
-    #     print(x.decorator, x.original_class)
-    #     y = Reconstitutor()(x.decorator, x.original_class, x.__class__.__name__)
-    #     print(type(y))
-    #     y.__dict__.update(x.__dict__)
-    #     print(y.name)
-    #     print(y.__class__.__name__)
-    #     self.assertEqual(y, x)
+        self.assert_original_acts_same_as_pickled(x, turns=10)