Fix failing tests rebased for the dev branch (#1372)

* Added new SpitefulCC Player to grudger.py, updated the list of all strategies and added coverage test in test_grudger.py

* changed 236 strategies to 237 in docs/index.rst

* changed SpitefulCC classifier and added strategy description

* changed description spitefulCC strategy

* Fix doctest.

This was failing on #1364
but the fix is trivial.

* Correct expected actions for meta strategy.

* Run black and isort.

Co-authored-by: Laura Romero <[email protected]>

Author: drvinceknight

axelrod/ecosystem.py

@@ -33,7 +33,7 @@ def __init__(
         population: List[int] = None,
     ) -> None:
         """Create a new ecosystem.
-        
+
         Parameters
         ----------
         results: ResultSet
@@ -83,7 +83,7 @@ def __init__(
 
     def reproduce(self, turns: int):
         """Reproduce populations according to the payoff matrix.
-        
+
         Parameters
         ----------
         turns: int

axelrod/game.py

@@ -20,7 +20,7 @@ def __init__(
         self, r: Score = 3, s: Score = 0, t: Score = 5, p: Score = 1
     ) -> None:
         """Create a new game object.
-        
+
         Parameters
         ----------
         r: int or float

axelrod/graph.py

@@ -9,20 +9,20 @@
 
 class Graph(object):
     """Weighted and directed graph class.
-    
+
     This class is intended for the graph associated to a Markov process,
     since it gives easy access to the neighbors of a particular state.
 
     Vertices can be any hashable Python object.
-    
+
     Initialize with a list of edges:
         [[node1, node2, weights], ...]
     Weights can be omitted for an undirected graph.
 
     For efficiency, neighbors are cached in dictionaries. Undirected
     graphs are implemented as directed graphs in which every edge (s, t)
     has the opposite edge (t, s).
-    
+
     Attributes
     ----------
     directed: Boolean indicating whether the graph is directed
@@ -31,7 +31,7 @@ class Graph(object):
         all tails to their edge weights (None means no weight)
     in_mapping: a dictionary mapping all tails to dictionaries that map
         all heads to their edge weights (none means to weight)
-    
+
     Properties
     ----------
     vertices: the set of vertices in the graph

axelrod/load_data_.py

@@ -56,7 +56,12 @@ def load_pso_tables(filename="pso_gambler.csv", directory="data"):
     rows = load_file(filename, directory)
     d = dict()
     for row in rows:
-        name, a, b, c, = str(row[0]), int(row[1]), int(row[2]), int(row[3])
+        name, a, b, c, = (
+            str(row[0]),
+            int(row[1]),
+            int(row[2]),
+            int(row[3]),
+        )
         values = list(map(float, row[4:]))
         d[(name, int(a), int(b), int(c))] = values
     return d

axelrod/result_set.py

@@ -152,8 +152,10 @@ def _reshape_out(
             "DD to C count",
             "DD to D count",
         ]
-        self.state_to_action_distribution = self._build_state_to_action_distribution(
-            sum_per_player_opponent_df[columns]
+        self.state_to_action_distribution = (
+            self._build_state_to_action_distribution(
+                sum_per_player_opponent_df[columns]
+            )
         )
         self.normalised_state_to_action_distribution = (
             self._build_normalised_state_to_action_distribution()

axelrod/strategies/_strategies.py

@@ -142,6 +142,7 @@
     GrudgerAlternator,
     OppositeGrudger,
     SoftGrudger,
+    SpitefulCC,
 )
 from .grumpy import Grumpy
 from .handshake import Handshake
@@ -467,6 +468,7 @@
     SolutionB1,
     SolutionB5,
     SpitefulTitForTat,
+    SpitefulCC,
     Stalker,
     StochasticCooperator,
     StochasticWSLS,

axelrod/strategies/cooperator.py

@@ -59,8 +59,9 @@ def strategy(self, opponent: Player) -> Action:
         After 3 rounds, if opponent has not defected to a max history depth of
         10, defect.
         """
-        if self._has_played_enough_rounds_to_be_tricky() and self._opponents_has_cooperated_enough_to_be_tricky(
-            opponent
+        if (
+            self._has_played_enough_rounds_to_be_tricky()
+            and self._opponents_has_cooperated_enough_to_be_tricky(opponent)
         ):
             return D
         return C

axelrod/strategies/grudger.py

@@ -167,8 +167,7 @@ def __init__(self) -> None:
         self.grudge_memory = 0
 
     def strategy(self, opponent: Player) -> Action:
-        """Begins by playing C, then plays D, D, D, D, C, C against a defection
-        """
+        """Begins by playing C, then plays D, D, D, D, C, C against a defection"""
         if self.grudged:
             strategy = [D, D, D, C, C][self.grudge_memory]
             self.grudge_memory += 1
@@ -310,3 +309,35 @@ def strategy(self, opponent: Player) -> Action:
 
     def __repr__(self) -> str:
         return "%s: n=%s,d=%s,c=%s" % (self.name, self.n, self.d, self.c)
+
+
+class SpitefulCC(Player):
+    """
+    Behaves like Grudger after cooperating for 2 turns
+
+    Names:
+
+    - spiteful_cc: [Mathieu2015]_
+    """
+
+    name = "SpitefulCC"
+    classifier = {
+        "memory_depth": float("inf"),  # Long memory
+        "stochastic": False,
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    @staticmethod
+    def strategy(opponent: Player) -> Action:
+        """
+        Cooperates until the oponent defects, then defects forever.
+        Always cooperates twice at the start.
+        """
+        if len(opponent.history) < 2:
+            return C
+        elif opponent.defections:
+            return D
+        return C

axelrod/strategies/human.py

@@ -118,12 +118,14 @@ def _status_messages(self):
                 if PROMPT2
                 else lambda cli: [(token_toolbar, self._history_toolbar())]
             )
-            print_statement = "{}Turn {}: {} played {}, opponent played {}".format(
-                linesep,
-                len(self.history),
-                self.human_name,
-                self.symbols[self.history[-1]],
-                self.symbols[self.history.coplays[-1]],
+            print_statement = (
+                "{}Turn {}: {} played {}, opponent played {}".format(
+                    linesep,
+                    len(self.history),
+                    self.human_name,
+                    self.symbols[self.history[-1]],
+                    self.symbols[self.history.coplays[-1]],
+                )
             )
         else:
             toolbar = None

axelrod/strategies/lookerup.py

@@ -535,7 +535,8 @@ def mutate(self):
             if r < self.mutation_probability:
                 initial_actions[i] = initial_actions[i].flip()
         return self.create_new(
-            lookup_dict=lookup_dict, initial_actions=tuple(initial_actions),
+            lookup_dict=lookup_dict,
+            initial_actions=tuple(initial_actions),
         )
 
     def crossover(self, other):