Revert "Run black"

This reverts commit c50a6e3.

Author: drvinceknight

.prepare-commit-msg.py

@@ -41,9 +41,7 @@
 
 if branch.startswith(issue_prefix):
     issue_number = re.match("%s(.*)" % issue_prefix, branch).group(1)
-    print(
-        "prepare-commit-msg: Prepending [#%s] to commit message" % issue_number
-    )
+    print("prepare-commit-msg: Prepending [#%s] to commit message" % issue_number)
 
     with open(commit_msg_filepath, "r+") as f:
         content = f.read()

axelrod/evolvable_player.py

@@ -7,7 +7,6 @@
 
 class InsufficientParametersError(Exception):
     """Error indicating that insufficient parameters were specified to initialize an Evolvable Player."""
-
     def __init__(self, *args):
         super().__init__(*args)
 
@@ -50,7 +49,7 @@ def create_new(self, **kwargs):
     def serialize_parameters(self):
         """Serialize parameters."""
         pickled = dumps(self.init_kwargs)  # bytes
-        s = base64.b64encode(pickled).decode("utf8")  # string
+        s = base64.b64encode(pickled).decode('utf8')  # string
         return s
 
     @classmethod

axelrod/fingerprint.py

@@ -42,7 +42,7 @@ def _create_points(step: float, progress_bar: bool = True) -> List[Point]:
     num = int((1 / step) // 1) + 1
 
     if progress_bar:
-        p_bar = tqdm.tqdm(total=num ** 2, desc="Generating points")
+        p_bar = tqdm.tqdm(total=num**2, desc="Generating points")
 
     points = []
     for x in np.linspace(0, 1, num):
@@ -88,8 +88,8 @@ def _create_jossann(point: Point, probe: Any) -> Player:
 
     if x + y >= 1:
         joss_ann = DualTransformer()(
-            JossAnnTransformer((1 - x, 1 - y))(probe_class)
-        )(**init_kwargs)
+            JossAnnTransformer((1 - x, 1 - y))(
+                probe_class))(**init_kwargs)
     else:
         joss_ann = JossAnnTransformer((x, y))(probe_class)(**init_kwargs)
     return joss_ann
@@ -177,10 +177,7 @@ def _generate_data(interactions: dict, points: list, edges: list) -> dict:
     """
     edge_scores = [
         np.mean(
-            [
-                compute_final_score_per_turn(scores)[0]
-                for scores in interactions[edge]
-            ]
+            [compute_final_score_per_turn(scores)[0] for scores in interactions[edge]]
         )
         for edge in edges
     ]
@@ -218,9 +215,7 @@ def _reshape_data(data: dict, points: list, size: int) -> np.ndarray:
 
 class AshlockFingerprint(object):
     def __init__(
-        self,
-        strategy: Union[type, Player],
-        probe: Union[type, Player] = axl.TitForTat,
+        self, strategy: Union[type, Player], probe: Union[type, Player] = axl.TitForTat
     ) -> None:
         """
         Parameters
@@ -282,7 +277,7 @@ def fingerprint(
         processes: int = None,
         filename: str = None,
         progress_bar: bool = True,
-        seed: int = None,
+        seed: int = None
     ) -> dict:
         """Build and play the spatial tournament.
 
@@ -328,11 +323,8 @@ def fingerprint(
 
         self.step = step
         self.spatial_tournament = axl.Tournament(
-            tourn_players,
-            turns=turns,
-            repetitions=repetitions,
-            edges=edges,
-            seed=seed,
+            tourn_players, turns=turns, repetitions=repetitions, edges=edges,
+            seed=seed
         )
         self.spatial_tournament.play(
             build_results=False,
@@ -440,7 +432,7 @@ def fingerprint(
         processes: int = None,
         filename: str = None,
         progress_bar: bool = True,
-        seed: int = None,
+        seed: int = None
     ) -> np.array:
         """Creates a spatial tournament to run the necessary matches to obtain
         fingerprint data.
@@ -487,7 +479,7 @@ def fingerprint(
             turns=turns,
             noise=noise,
             repetitions=repetitions,
-            seed=seed,
+            seed=seed
         )
         tournament.play(
             filename=filename,
@@ -524,9 +516,7 @@ def analyse_cooperation_ratio(filename):
             opponent in each turn. The ith row corresponds to the ith opponent
             and the jth column the jth turn.
         """
-        did_c = np.vectorize(
-            lambda actions: [int(action == "C") for action in actions]
-        )
+        did_c = np.vectorize(lambda actions: [int(action == "C") for action in actions])
 
         cooperation_rates = {}
         df = dd.read_csv(filename)
@@ -535,10 +525,7 @@ def analyse_cooperation_ratio(filename):
         df = df[df["Player index"] == 0][["Opponent index", "Actions"]]
 
         for _, row in df.iterrows():
-            opponent_index, player_history = (
-                row["Opponent index"],
-                row["Actions"],
-            )
+            opponent_index, player_history = row["Opponent index"], row["Actions"]
             if opponent_index in cooperation_rates:
                 cooperation_rates[opponent_index].append(did_c(player_history))
             else:
@@ -603,8 +590,7 @@ def plot(
 
         if display_names:
             plt.yticks(
-                range(len(self.opponents)),
-                [str(player) for player in self.opponents],
+                range(len(self.opponents)), [str(player) for player in self.opponents]
             )
         else:
             plt.yticks([0, len(self.opponents) - 1], [0, 1])

axelrod/game.py

@@ -16,9 +16,7 @@ class Game(object):
         The numerical score attribute to all combinations of action pairs.
     """
 
-    def __init__(
-        self, r: Score = 3, s: Score = 0, t: Score = 5, p: Score = 1
-    ) -> None:
+    def __init__(self, r: Score = 3, s: Score = 0, t: Score = 5, p: Score = 1) -> None:
         """Create a new game object.
         
         Parameters
@@ -32,12 +30,7 @@ def __init__(
         p: int or float
             Score obtained by both player for mutual defection.
         """
-        self.scores = {
-            (C, C): (r, r),
-            (D, D): (p, p),
-            (C, D): (s, t),
-            (D, C): (t, s),
-        }
+        self.scores = {(C, C): (r, r), (D, D): (p, p), (C, D): (s, t), (D, C): (t, s)}
 
     def RPST(self) -> Tuple[Score, Score, Score, Score]:
         """Returns game matrix values in Press and Dyson notation."""

axelrod/graph.py

@@ -155,9 +155,8 @@ def attached_complete_graphs(length, loops=True, directed=False):
     for cluster in range(2):
         for i in range(length):
             for j in range(i + 1, length):
-                edges.append(
-                    ("{}:{}".format(cluster, i), "{}:{}".format(cluster, j))
-                )
+                edges.append(("{}:{}".format(cluster, i),
+                              "{}:{}".format(cluster, j)))
     # Attach at one node
     edges.append(("0:0", "1:0"))
     graph = Graph(directed=directed, edges=edges)

axelrod/history.py

@@ -82,9 +82,7 @@ def __eq__(self, other):
         if isinstance(other, list):
             return self._plays == other
         elif isinstance(other, History):
-            return (
-                self._plays == other._plays and self._coplays == other._coplays
-            )
+            return self._plays == other._plays and self._coplays == other._coplays
         raise TypeError("Cannot compare types.")
 
     def __getitem__(self, key):
@@ -123,9 +121,7 @@ def __init__(self, memory_depth, plays=None, coplays=None):
     def flip_plays(self):
         """Creates a flipped plays history for use with DualTransformer."""
         flipped_plays = [action.flip() for action in self._plays]
-        return self.__class__(
-            self.memory_depth, plays=flipped_plays, coplays=self._coplays
-        )
+        return self.__class__(self.memory_depth, plays=flipped_plays, coplays=self._coplays)
 
     def append(self, play, coplay):
         """Appends a new (play, coplay) pair an updates metadata for

axelrod/interaction_utils.py

@@ -32,8 +32,7 @@ def compute_final_score(interactions, game=None):
         return None
 
     final_score = tuple(
-        sum([score[player_index] for score in scores])
-        for player_index in [0, 1]
+        sum([score[player_index] for score in scores]) for player_index in [0, 1]
     )
     return final_score
 

axelrod/match.py

@@ -29,7 +29,7 @@ def __init__(
         noise=0,
         match_attributes=None,
         reset=True,
-        seed=None,
+        seed=None
     ):
         """
         Parameters
@@ -193,8 +193,7 @@ def play(self):
             result = []
             for _ in range(turns):
                 plays = self.simultaneous_play(
-                    self.players[0], self.players[1], self.noise
-                )
+                    self.players[0], self.players[1], self.noise)
                 result.append(plays)
 
             if self._cache_update_required:

axelrod/match_generator.py

@@ -12,7 +12,7 @@ def __init__(
         prob_end=None,
         edges=None,
         match_attributes=None,
-        seed=None,
+        seed=None
     ):
         """
         A class to generate matches. This is used by the Tournament class which

axelrod/moran.py

@@ -28,7 +28,7 @@ def __init__(
         fitness_transformation: Callable = None,
         mutation_method="transition",
         stop_on_fixation=True,
-        seed=None,
+        seed=None
     ) -> None:
         """
         An agent based Moran process class. In each round, each player plays a
@@ -93,9 +93,7 @@ def __init__(
         if m in ["atomic", "transition"]:
             self.mutation_method = m
         else:
-            raise ValueError(
-                "Invalid mutation method {}".format(mutation_method)
-            )
+            raise ValueError("Invalid mutation method {}".format(mutation_method))
         assert (mutation_rate >= 0) and (mutation_rate <= 1)
         assert (noise >= 0) and (noise <= 1)
         mode = mode.lower()
@@ -129,9 +127,7 @@ def __init__(
             d[str(p)] = p
         mutation_targets = dict()
         for key in sorted(keys):
-            mutation_targets[key] = [
-                v for (k, v) in sorted(d.items()) if k != key
-            ]
+            mutation_targets[key] = [v for (k, v) in sorted(d.items()) if k != key]
         self.mutation_targets = mutation_targets
 
         if interaction_graph is None:
@@ -150,18 +146,14 @@ def __init__(
         self.fitness_transformation = fitness_transformation
         # Map players to graph vertices
         self.locations = sorted(interaction_graph.vertices)
-        self.index = dict(
-            zip(sorted(interaction_graph.vertices), range(len(players)))
-        )
+        self.index = dict(zip(sorted(interaction_graph.vertices), range(len(players))))
         self.fixated = self.fixation_check()
 
     def set_players(self) -> None:
         """Copy the initial players into the first population, setting seeds as needed."""
         self.players = []
         for player in self.initial_players:
-            if (self.mutation_method == "atomic") and issubclass(
-                player.__class__, EvolvablePlayer
-            ):
+            if (self.mutation_method == "atomic") and issubclass(player.__class__, EvolvablePlayer):
                 # For reproducibility, we generate random seeds for evolvable players.
                 seed = next(self._bulk_random)
                 new_player = player.create_new(seed=seed)
@@ -171,9 +163,8 @@ def set_players(self) -> None:
                 self.players.append(player)
         self.populations = [self.population_distribution()]
 
-    def fitness_proportionate_selection(
-        self, scores: List, fitness_transformation: Callable = None
-    ) -> int:
+    def fitness_proportionate_selection(self,
+                                        scores: List, fitness_transformation: Callable = None) -> int:
         """Randomly selects an individual proportionally to score.
 
         Parameters
@@ -209,9 +200,7 @@ def mutate(self, index: int) -> Player:
 
         if self.mutation_method == "atomic":
             if not issubclass(self.players[index].__class__, EvolvablePlayer):
-                raise TypeError(
-                    "Player is not evolvable. Use a subclass of EvolvablePlayer."
-                )
+                raise TypeError("Player is not evolvable. Use a subclass of EvolvablePlayer.")
             return self.players[index].mutate()
 
         # Assuming mutation_method == "transition"
@@ -248,9 +237,7 @@ def death(self, index: int = None) -> int:
             # Select locally
             # index is not None in this case
             vertex = self._random.choice(
-                sorted(
-                    self.reproduction_graph.out_vertices(self.locations[index])
-                )
+                sorted(self.reproduction_graph.out_vertices(self.locations[index]))
             )
             i = self.index[vertex]
         return i
@@ -383,7 +370,7 @@ def score_all(self) -> List:
                 noise=self.noise,
                 game=self.game,
                 deterministic_cache=self.deterministic_cache,
-                seed=next(self._bulk_random),
+                seed=next(self._bulk_random)
             )
             match.play()
             match_scores = match.final_score_per_turn()
@@ -497,11 +484,8 @@ class ApproximateMoranProcess(MoranProcess):
     """
 
     def __init__(
-        self,
-        players: List[Player],
-        cached_outcomes: dict,
-        mutation_rate: float = 0,
-        seed: Optional[int] = None,
+        self, players: List[Player], cached_outcomes: dict, mutation_rate: float = 0,
+        seed: Optional[int] = None
     ) -> None:
         """
         Parameters
@@ -519,7 +503,7 @@ def __init__(
             noise=0,
             deterministic_cache=None,
             mutation_rate=mutation_rate,
-            seed=seed,
+            seed=seed
         )
         self.cached_outcomes = cached_outcomes
 
@@ -545,9 +529,7 @@ def score_all(self) -> List:
         scores = [0] * N
         for i in range(N):
             for j in range(i + 1, N):
-                player_names = tuple(
-                    [str(self.players[i]), str(self.players[j])]
-                )
+                player_names = tuple([str(self.players[i]), str(self.players[j])])
                 cached_score = self._get_scores_from_cache(player_names)
                 scores[i] += cached_score[0]
                 scores[j] += cached_score[1]