Run black and isort.

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/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

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):

axelrod/strategies/sequence_player.py

@@ -80,7 +80,7 @@ def __init__(self) -> None:
 
 
 class ThueMorseInverse(ThueMorse):
-    """ A player who plays the inverse of the Thue-Morse sequence.
+    """A player who plays the inverse of the Thue-Morse sequence.
 
     Names: