mostly fixed. branch switch

Author: eric-s-s

axelrod/strategy_transformers.py

@@ -9,9 +9,11 @@
 import copy
 import inspect
 import random
+from typing import Any
 from numpy.random import choice
 from .action import Action
 from .random_ import random_choice
+from .player import defaultdict, Player
 from importlib import import_module
 
 
@@ -59,9 +61,10 @@ def __init__(self, *args, **kwargs):
                 self.name_prefix = name_prefix
 
         def __reduce__(self):
+            factory_args = (strategy_wrapper, name_prefix, reclassifier)
             return (
                 DecoratorReBuilder(),
-                (strategy_wrapper, name_prefix, reclassifier,
+                (factory_args,
                  self.args, self.kwargs, self.name_prefix)
             )
 
@@ -96,8 +99,8 @@ def __call__(self, PlayerClass):
             # with `strategy_wrapper`
             def strategy(self, opponent):
                 if strategy_wrapper == dual_wrapper:
-                    # Dummy Action for dual_wrapper.
-                    # This is to avoid calling the strategy twice.
+                    # `dual_wrapper` is a special case that must not call the
+                    # strategy here. It is called inside the wrapper, instead.
                     proposed_action = C
                 else:
                     if is_strategy_static(PlayerClass):
@@ -147,23 +150,23 @@ def __repr__(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):
+
+                if player_can_be_pickled(self_):
                     return self_.__class__, (), self_.__dict__
 
-                else:
-                    decorators = []
-                    for klass in self_.__class__.mro():
-                        if hasattr(klass, 'decorator'):
-                            decorators.insert(0, klass.decorator)
-                        else:
-                            import_name = klass.__name__
-                            break
-
-                    return (
-                        StrategyReBuilder(),
-                        (decorators, import_name, self_.__module__),
-                        self_.__dict__
-                    )
+                decorators = []
+                for klass in self_.__class__.mro():
+                    import_name = klass.__name__
+                    if hasattr(klass, 'decorator'):
+                        decorators.insert(0, klass.decorator)
+                    if hasattr(class_module, import_name):
+                        break
+
+                return (
+                    StrategyReBuilder(),
+                    (decorators, import_name, self_.__module__),
+                    self_.__dict__
+                )
 
             # Define a new class and wrap the strategy method
             # Dynamically create the new class
@@ -185,11 +188,22 @@ def reduce_for_decorated_class(self_):
     return Decorator
 
 
-def is_strategy_static(player_class):
+def player_can_be_pickled(player: Player) -> bool:
+    """
+    Returns True if pickle.dump(player) does not raise pickle.PicklingError.
     """
+    class_module = import_module(player.__module__)
+    import_name = player.__class__.__name__
+    if not hasattr(class_module, import_name):
+        return False
 
-    :param player_class: Any class that inherits from axelrod.Player
-    :return: bool
+    to_test = getattr(class_module, import_name)
+    return to_test == player.__class__
+
+
+def is_strategy_static(player_class) -> bool:
+    """
+    Returns True if `player_class.strategy` is a `staticmethod`, else False.
     """
     for klass in player_class.mro():
         method = inspect.getattr_static(klass, 'strategy', default=None)
@@ -198,23 +212,26 @@ def is_strategy_static(player_class):
 
 
 class DecoratorReBuilder(object):
-    def __init__(self):
-        pass
-
-    def __call__(self, strategy_wrapper, name_prefix, reclassifier,
-                 args, kwargs, instance_name_prefix):
-        decorator_class = StrategyTransformerFactory(
-            strategy_wrapper, name_prefix, reclassifier
-        )
+    """
+    An object to build an anonymous Decorator obj from a set of pickle-able
+    parameters.
+    """
+    def __call__(self, factory_args: tuple, args: tuple, kwargs: dict,
+                 instance_name_prefix: str) -> Any:
+
+        decorator_class = StrategyTransformerFactory(*factory_args)
         kwargs['name_prefix'] = instance_name_prefix
         return decorator_class(*args, **kwargs)
 
 
 class StrategyReBuilder(object):
-    def __init__(self):
-        pass
+    """
+    An object to build a new instance of a player from an old instance
+    that could not normally be pickled.
+    """
+    def __call__(self, decorators: list, import_name: str,
+                 module_name: str) -> Player:
 
-    def __call__(self, decorators, import_name, module_name):
         module_ = import_module(module_name)
         import_class = getattr(module_, import_name)
 
@@ -277,7 +294,7 @@ def flip_wrapper(player, opponent, action):
     flip_wrapper, name_prefix="Flipped")
 
 
-def dual_wrapper(player, opponent, proposed_action):
+def dual_wrapper(player, opponent: Player, proposed_action: Action) -> Action:
     """Wraps the players strategy function to produce the Dual.
 
     The Dual of a strategy will return the exact opposite set of moves to the
@@ -298,32 +315,53 @@ def dual_wrapper(player, opponent, proposed_action):
     action: an axelrod.Action, C or D
     """
 
-    if not player.history:
-        player.original_player_history = []
-
-    temp_history = player.history[:]
-    player.history = player.original_player_history[:]
-
-    switch_cooperations_and_defections(player)
+    flip_play_attributes(player)
 
     if is_strategy_static(player.original_class):
         action = player.original_class.strategy(opponent)
     else:
         action = player.original_class.strategy(player, opponent)
 
-    player.history = temp_history[:]
-    switch_cooperations_and_defections(player)
+    flip_play_attributes(player)
 
-    player.original_player_history.append(action)
     return action.flip()
 
 
-def switch_cooperations_and_defections(player):
+def flip_play_attributes(player: Player) -> None:
+    """
+    Flips all the attributes created by `player.play`:
+        - `player.history`,
+        - `player.cooperations`,
+        - `player.defectsions`,
+        - `player.state_distribution`,
+    """
+    flip_history(player)
+    switch_cooperations_and_defections(player)
+    flip_state_distribution(player)
+
+
+def flip_history(player: Player) -> None:
+    """Flips all the actions in `player.history`."""
+    new_history = [action.flip() for action in player.history]
+    player.history = new_history
+
+
+def switch_cooperations_and_defections(player: Player) -> None:
+    """Exchanges `player.cooperations` and `player.defections`."""
     temp = player.cooperations
     player.cooperations = player.defections
     player.defections = temp
 
 
+def flip_state_distribution(player: Player) -> None:
+    """Flips all the player's actions in `player.state_distribution`."""
+    new_distribution = defaultdict(int)
+    for key, val in player.state_distribution.items():
+        new_key = (key[0].flip(), key[1])
+        new_distribution[new_key] = val
+    player.state_distribution = new_distribution
+
+
 DualTransformer = StrategyTransformerFactory(dual_wrapper, name_prefix="Dual")
 
 

axelrod/tests/unit/test_pickling.py

@@ -126,9 +126,14 @@ class RetaliateUntilApology(axl.Cooperator):
 class TrackHistory(axl.Cooperator):
     pass
 
+@st.IdentityTransformer()
+class Identity(axl.Cooperator):
+    pass
+
 transformed_no_prefix = [Apology, DeadlockBreaking, Flip, Final, Forgiver,
                          Grudge, Initial, JossAnn, Mixed, Nice, Noisy,
-                         Retaliation, RetaliateUntilApology, TrackHistory, Dual]
+                         Retaliation, RetaliateUntilApology, TrackHistory, Dual,
+                         Identity]
 
 transformer_instances = [
     st.ApologyTransformer([D], [C]),
@@ -145,12 +150,17 @@ class TrackHistory(axl.Cooperator):
     st.NoisyTransformer(0.2),
     st.RetaliationTransformer(3),
     st.RetaliateUntilApologyTransformer(),
-    st.TrackHistoryTransformer()
+    st.TrackHistoryTransformer(),
+    st.IdentityTransformer()
 ]
 
 
 class TestPickle(unittest.TestCase):
 
+    def assert_orignal_equals_pickled(self, player, turns=10):
+        self.assert_original_plays_same_as_pickled(player, turns)
+        self.assert_mutated_instance_same_as_pickled(player)
+
     def assert_original_plays_same_as_pickled(self, player, turns=10):
         copy = pickle.loads(pickle.dumps(player))
         opponent_1 = axl.CyclerCCCDCD()
@@ -166,6 +176,7 @@ def assert_original_plays_same_as_pickled(self, player, turns=10):
         self.assertEqual(result_1, result_2)
 
     def assert_mutated_instance_same_as_pickled(self, player):
+        player.reset()
         turns = 5
         opponent = axl.Alternator()
         for _ in range(turns):
@@ -175,11 +186,11 @@ def assert_mutated_instance_same_as_pickled(self, player):
 
     def test_parameterized_player(self):
         player = axl.Cycler('DDCCDD')
-        self.assert_mutated_instance_same_as_pickled(player)
+        self.assert_orignal_equals_pickled(player)
 
     def test_sequence_player(self):
         player = axl.ThueMorse()
-        self.assert_mutated_instance_same_as_pickled(player)
+        self.assert_orignal_equals_pickled(player)
 
     def test_final_transformer_called(self):
         player = axl.Alexei()
@@ -196,20 +207,17 @@ def test_nice_transformer_class(self):
 
     def test_pickling_all_strategies(self):
         for s in axl.strategies:
-            player = s()
-            player.play(axl.Cooperator())
-            reconstituted = pickle.loads(pickle.dumps(player))
-            self.assertEqual(reconstituted, player)
+            self.assert_orignal_equals_pickled(s())
 
     def test_pickling_all_transformers_as_decorated_classes(self):
         for s in transformed_no_prefix:
             player = s()
-            self.assert_mutated_instance_same_as_pickled(player)
+            self.assert_orignal_equals_pickled(player)
 
     def test_pickling_all_transformers_as_instance_called_on_a_class(self):
         for transformer in transformer_instances:
             player = transformer(axl.Cooperator)()
-            self.assert_mutated_instance_same_as_pickled(player)
+            self.assert_orignal_equals_pickled(player)
 
     def test_created_on_the_spot_multiple_transformers(self):
         klass = st.FlipTransformer()(axl.Cooperator)
@@ -218,6 +226,7 @@ def test_created_on_the_spot_multiple_transformers(self):
         copy = pickle.loads(pickle.dumps(player))
 
         self.assertEqual(player, copy)
+        self.assert_mutated_instance_same_as_pickled(player)
 
     def test_class_and_instance_name_different_single_flip(self):
         player = SingleFlip()
@@ -307,42 +316,9 @@ def test_with_various_name_prefixes(self):
                          'FliptasticCooperator')
         self.assert_mutated_instance_same_as_pickled(new_prefix)
 
-    def test_limitations__pickling_a_stupid_case(self):
+    def test_dynamic_class_no_name_prefix(self):
         player = st.FlipTransformer(name_prefix=None)(axl.Cooperator)()
 
         self.assertEqual(player.__class__.__name__, 'Cooperator')
+        self.assert_mutated_instance_same_as_pickled(player)
 
-        self.assertRaises(pickle.PicklingError, pickle.dumps, player)
-
-    def test_regression_test_dual_transformer_with_lookerup(self):
-        self.assert_dual_wrapper_correct(axl.LookerUp)
-        self.assert_dual_wrapper_correct(axl.EvolvedLookerUp2_2_2)
-
-    def test_regression_test_dual_jossann(self):
-        klass = st.JossAnnTransformer((0.2, 0.3))(axl.Alternator)
-        self.assert_dual_wrapper_correct(klass)
-
-        klass = st.JossAnnTransformer((0.5, 0.4))(axl.EvolvedLookerUp2_2_2)
-        self.assert_dual_wrapper_correct(klass)
-
-    def test_dual_transformer_with_fsm_and_sequence_players(self):
-
-        for s in axl.strategies:
-            self.assert_dual_wrapper_correct(s)
-
-    def assert_dual_wrapper_correct(self, player_class):
-        p1 = player_class()
-        p2 = st.DualTransformer()(player_class)()
-        p3 = axl.CyclerCCD()  # Cycles 'CCD'
-
-        axl.seed(0)
-        for _ in range(10):
-            p1.play(p3)
-
-        p3.reset()
-
-        axl.seed(0)
-        for _ in range(10):
-            p2.play(p3)
-
-        self.assertEqual(p1.history, [x.flip() for x in p2.history])