Add Alexei strategy

axelrod/strategies/_strategies.py

@@ -75,7 +75,7 @@
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
     SuspiciousTitForTat, AntiTitForTat, HardTitForTat, HardTitFor2Tats,
     OmegaTFT, Gradual, ContriteTitForTat, SlowTitForTwoTats, AdaptiveTitForTat,
-    SpitefulTitForTat, SlowTitForTwoTats2)
+    SpitefulTitForTat, SlowTitForTwoTats2, Alexei)
 from .verybad import VeryBad
 from .worse_and_worse import (WorseAndWorse, KnowledgeableWorseAndWorse,
                               WorseAndWorse2, WorseAndWorse3)
@@ -86,6 +86,7 @@
     Adaptive,
     AdaptiveTitForTat,
     Aggravater,
+    Alexei,
     ALLCorALLD,
     Alternator,
     AlternatorHunter,

axelrod/strategies/titfortat.py

@@ -1,6 +1,6 @@
 from axelrod.actions import Actions, Action
 from axelrod.player import Player
-from axelrod.strategy_transformers import TrackHistoryTransformer
+from axelrod.strategy_transformers import TrackHistoryTransformer, FinalTransformer
 
 C, D = Actions.C, Actions.D
 
@@ -636,3 +636,31 @@ def strategy(self, opponent: Player) -> Action:
 
         # Otherwise play previous move
         return self.history[-1]
+
+@FinalTransformer((D, ) name_prefix=None)
+class Alexei(Player):
+    """
+    Plays similar to Tit-for-Tat, but always defect on last turn.
+
+    Names:
+
+    - From http://lesswrong.com/lw/7f2/prisoners_dilemma_tournament_results/    
+    """
+
+    name = 'Alexei'
+    classifier = {
+        'memory_depth': 1,
+        'stochastic': False,
+        'makes_use_of': {'length'},
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent: Player) -> Action:
+        if not self.history:
+            return C
+        if opponent.history[-1] == D:
+            return D
+        return C

axelrod/tests/strategies/test_titfortat.py

@@ -563,3 +563,54 @@ def test_strategy(self):
         actions = [(C, C), (C, C), (C, D), (C, D), (D, C), (D, D), (D, D),
                     (D, C), (D, C), (C, D), (C, D)]
         self.versus_test(opponent, expected_actions=actions)
+
+class TestAlexei(TestPlayer):
+    """
+    Note that this test is referred to in the documentation as an example on
+    writing tests.  If you modify the tests here please also modify the
+    documentation.
+    """
+
+    name = "Alexei: D"
+    player = axelrod.Alexei
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': False,
+        'makes_use_of': {'length'},
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+        self.second_play_test(rCC=C, rCD=D, rDC=C, rDD=D)
+
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)
+
+        actions = [(C, C), (C, C), (C, C), (C, C), (D, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions)
+
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions,
+                         match_attributes={"length": -1})
+
+        actions = [(C, D), (D, D), (D, C), (C, C), (D, D)]
+        self.versus_test(axelrod.Random(), expected_actions=actions,
+                         seed=0)
+
+        actions = [(C, C), (C, D), (D, D), (D, C)]
+        self.versus_test(axelrod.Random(), expected_actions=actions,
+                         seed=1)
+
+        opponent = axelrod.MockPlayer(actions=[C, D])
+        actions = [(C, C), (C, D), (D, C), (D, D)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[C, C, D, D, C, D])
+        actions = [(C, C), (C, C), (C, D), (D, D), (D, C), (D, D)]
+        self.versus_test(opponent, expected_actions=actions)

docs/tutorials/advanced/classification_of_strategies.rst

@@ -57,7 +57,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    27
+    28
 
 Multiple filters can be specified within the filterset dictionary. To specify a
 range of memory_depth values, we can use the 'min_memory_depth' and
@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    49
+    50
 
 We can also identify strategies that make use of particular properties of the
 tournament. For example, here is the number of strategies that  make use of the
@@ -80,7 +80,7 @@ length of each match of the tournament::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    25
+    26
 
 Note that in the filterset dictionary, the value for the 'makes_use_of' key
 must be a list. Here is how we might identify the number of strategies that use