Some attempts to fix.

Author: FakeNameSE

axelrod/strategies/titfortat.py

@@ -2,7 +2,6 @@
 from axelrod.player import Player
 from axelrod.strategy_transformers import TrackHistoryTransformer, FinalTransformer
 from axelrod.random_ import random_choice
-import random
 
 C, D = Actions.C, Actions.D
 
@@ -95,16 +94,21 @@ def strategy(opponent: Player) -> Action:
         return D if D in opponent.history[-2:] else C
 
 class DynamicTwoTitsForTat(Player):
-    """A player starts by cooperating and then mimics previous move by 
-    opponent with a dynamic bias based off of the opponents ratio of 
-    cooperations to total moves (so their current probability of 
-    cooperating towards cooporating regardless of the move 
-    (aka: forgiveness)."""
+    """
+    A player starts by cooperating and then punishes its opponent's 
+    defectiions by opponent with a dynamic bias based off of the 
+    opponents ratio of cooperations to total moves (so their current 
+    probability of cooperating towards cooporating regardless of the 
+    move (aka: forgiveness)).
+    Names:
+
+     - Dynamic Two Tits For Tat: Original name by Grant Garrett-Grossman.
+    """
 
     name = 'Dynamic Two Tits For Tat'
     classifier = {
         'memory_depth': 2,  # Long memory, memory-2
-        'stochastic': False,
+        'stochastic': True,
         'makes_use_of': set(),
         'long_run_time': False,
         'inspects_source': False,
@@ -119,9 +123,8 @@ def strategy(opponent):
             # Make sure we cooporate first turn
             return C
         if D in opponent.history[-2:]:
-            # Probability of turning the other cheek based off of 
-            # opponent's probability of defection
-            if random.random() < (opponent.cooperations / len(opponent.history)):
+            # Probability of cooperating regardless
+            if random_choice(opponent.cooperations / len(opponent.history)):
                 return C
             else:
                 return D

axelrod/tests/strategies/test_titfortat.py

@@ -120,27 +120,36 @@ class TestDynamicTwoTitsForTat(TestPlayer):
     player = axelrod.DynamicTwoTitsForTat
     expected_classifier = {
         'memory_depth': 2,
-        'stochastic': False,
+        'stochastic': True,
         'makes_use_of': set(),
         'inspects_source': False,
         'manipulates_source': False,
         'manipulates_state': False
     }
 
     def test_strategy(self):
+        # First move is to cooperate
         self.first_play_test(C)
-        self.second_play_test(rCC=C, rCD=D, rDC=C, rDD=D)
-
-        # Will cooperate if opponent cooperates/.
-        actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
-        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
-        # Will defect twice when last turn of opponent was defection.
-        opponent = axelrod.MockPlayer(actions=[D, C, C, D, C])
-        actions = [(C, D), (D, C), (D, C), (C, D), (D, C)]
-        self.versus_test(opponent, expected_actions=actions)
-        # Test against defector
-        actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
-        self.versus_test(axelrod.Defector(), expected_actions=actions)
+        # Test that it is stochastic        
+ 
+        opponent = axelrod.MockPlayer(actions=[D, C, D, D, C])
+        actions = [(C, D), (C,C), (C,D), (C,D), (C,C)]
+        self.versus_test(opponent, expected_actions=actions, seed=2)
+        
+        opponent = axelrod.MockPlayer(actions=[D, C, D, D, C])
+        actions = [(C, D), (C,C), (C,D), (C,D), (D,C)]
+        self.versus_test(opponent, expected_actions=actions, seed=13)
+        
+        ## Will cooperate if opponent cooperates.
+        #actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
+        #self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+        ## Will defect twice when last turn of opponent was defection.
+        #opponent = axelrod.MockPlayer(actions=[D, C, C, D, C])
+        #actions = [(C, D), (D, C), (D, C), (C, D), (D, C)]
+        #self.versus_test(opponent, expected_actions=actions)
+        ## Test against defector
+        #actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
+        #self.versus_test(axelrod.Defector(), expected_actions=actions)
 
 class TestBully(TestPlayer):
 

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    66
+    67
 
 Or, to find out how many strategies only use 1 turn worth of memory to
 make a decision::