Run black on all files

Author: gaffney2010

axelrod/compute_finite_state_machine_memory.py

@@ -47,10 +47,7 @@ def __hash__(self):
 
     def __eq__(self, other_memit) -> bool:
         """In action and out actions are the same."""
-        return (
-            self.in_act == other_memit.in_act
-            and self.out_act == other_memit.out_act
-        )
+        return self.in_act == other_memit.in_act and self.out_act == other_memit.out_act
 
     def __lt__(self, other_memit) -> bool:
         return repr(self) < repr(other_memit)
@@ -110,9 +107,10 @@ def get_accessible_transitions(
     accessible_transitions = dict()
     for trans in transition_iterator(transitions):
         if trans.state in accessible_states:
-            accessible_transitions[
-                (trans.state, trans.last_opponent_action)
-            ] = (trans.next_state, trans.next_action)
+            accessible_transitions[(trans.state, trans.last_opponent_action)] = (
+                trans.next_state,
+                trans.next_action,
+            )
 
     return accessible_transitions
 
@@ -179,9 +177,7 @@ def get_memory_from_transitions(
         transitions = get_accessible_transitions(transitions, initial_state)
 
     # Get the incoming actions for each state.
-    incoming_action_by_state = defaultdict(
-        set
-    )  # type: DefaultDict[int, Set[Action]]
+    incoming_action_by_state = defaultdict(set)  # type: DefaultDict[int, Set[Action]]
     for trans in transition_iterator(transitions):
         incoming_action_by_state[trans.next_state].add(trans.next_action)
 
@@ -193,23 +189,17 @@ def get_memory_from_transitions(
         # That is to say that the opponent could do anything
         for out_action in all_actions:
             # More recent in action history
-            starting_node = Memit(
-                trans.next_action, trans.next_state, out_action
-            )
+            starting_node = Memit(trans.next_action, trans.next_state, out_action)
             # All incoming paths to current state
             for in_action in incoming_action_by_state[trans.state]:
                 # Less recent in action history
-                ending_node = Memit(
-                    in_action, trans.state, trans.last_opponent_action
-                )
+                ending_node = Memit(in_action, trans.state, trans.last_opponent_action)
                 memit_edges[starting_node].add(ending_node)
 
     all_memits = list(memit_edges.keys())
 
     pair_nodes = set()
-    pair_edges = defaultdict(
-        set
-    )  # type: DefaultDict[MemitPair, Set[MemitPair]]
+    pair_edges = defaultdict(set)  # type: DefaultDict[MemitPair, Set[MemitPair]]
     # Loop through all pairs of memits.
     for x, y in [(x, y) for x in all_memits for y in all_memits]:
         if x == y and x.state == y.state:
@@ -236,9 +226,7 @@ def get_memory_from_transitions(
     next_action_by_memit = dict()
     for trans in transition_iterator(transitions):
         for in_action in incoming_action_by_state[trans.state]:
-            memit_key = Memit(
-                in_action, trans.state, trans.last_opponent_action
-            )
+            memit_key = Memit(in_action, trans.state, trans.last_opponent_action)
             next_action_by_memit[memit_key] = trans.next_action
 
     # Calculate the longest path.
@@ -263,4 +251,3 @@ def get_memory_from_transitions(
     if len(next_action_set) == 1:
         return 0
     return 1
-

axelrod/evolvable_player.py

@@ -7,6 +7,7 @@
 
 class InsufficientParametersError(Exception):
     """Error indicating that insufficient parameters were specified to initialize an Evolvable Player."""
+
     def __init__(self, *args):
         super().__init__(*args)
 
@@ -38,7 +39,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/graph.py

@@ -155,8 +155,7 @@ 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/moran.py

@@ -57,7 +57,7 @@ def __init__(
         reproduction_graph: Graph = None,
         fitness_transformation: Callable = None,
         mutation_method="transition",
-        stop_on_fixation=True
+        stop_on_fixation=True,
     ) -> None:
         """
         An agent based Moran process class. In each round, each player plays a
@@ -193,7 +193,9 @@ 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"

axelrod/strategies/adaptor.py

@@ -39,12 +39,13 @@ class AbstractAdaptor(Player):
         "manipulates_state": False,
     }
 
-    def __init__(self, delta: Dict[Tuple[Action, Action], float],
-                 perr: float = 0.01) -> None:
+    def __init__(
+        self, delta: Dict[Tuple[Action, Action], float], perr: float = 0.01
+    ) -> None:
         super().__init__()
         self.perr = perr
         self.delta = delta
-        self.s = 0.
+        self.s = 0.0
 
     def strategy(self, opponent: Player) -> Action:
         if self.history:
@@ -54,7 +55,8 @@ def strategy(self, opponent: Player) -> Action:
 
         # Compute probability of Cooperation
         p = self.perr + (1.0 - 2 * self.perr) * (
-            heaviside(self.s + 1, 1) - heaviside(self.s - 1, 1))
+            heaviside(self.s + 1, 1) - heaviside(self.s - 1, 1)
+        )
         # Draw action
         action = random_choice(p)
         return action
@@ -74,10 +76,10 @@ class AdaptorBrief(AbstractAdaptor):
 
     def __init__(self) -> None:
         delta = {
-            (C, C): 0.,         # R
+            (C, C): 0.0,  # R
             (C, D): -1.001505,  # S
-            (D, C): 0.992107,   # T
-            (D, D): -0.638734   # P
+            (D, C): 0.992107,  # T
+            (D, D): -0.638734,  # P
         }
         super().__init__(delta=delta)
 
@@ -96,9 +98,9 @@ class AdaptorLong(AbstractAdaptor):
 
     def __init__(self) -> None:
         delta = {
-            (C, C): 0.,        # R
+            (C, C): 0.0,  # R
             (C, D): 1.888159,  # S
             (D, C): 1.858883,  # T
-            (D, D): -0.995703  # P
+            (D, D): -0.995703,  # P
         }
         super().__init__(delta=delta)

axelrod/strategies/ann.py

@@ -3,7 +3,11 @@
 import numpy.random as random
 from axelrod.action import Action
 from axelrod.load_data_ import load_weights
-from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, crossover_lists
+from axelrod.evolvable_player import (
+    EvolvablePlayer,
+    InsufficientParametersError,
+    crossover_lists,
+)
 from axelrod.player import Player
 
 
@@ -191,8 +195,7 @@ class ANN(Player):
     }
 
     def __init__(
-        self, num_features: int, num_hidden: int,
-        weights: List[float] = None
+        self, num_features: int, num_hidden: int, weights: List[float] = None
     ) -> None:
         super().__init__()
         self.num_features = num_features
@@ -222,43 +225,57 @@ def strategy(self, opponent: Player) -> Action:
 
 class EvolvableANN(ANN, EvolvablePlayer):
     """Evolvable version of ANN."""
+
     name = "EvolvableANN"
 
     def __init__(
-        self, num_features: int, num_hidden: int,
+        self,
+        num_features: int,
+        num_hidden: int,
         weights: List[float] = None,
         mutation_probability: float = None,
         mutation_distance: int = 5,
     ) -> None:
-        num_features, num_hidden, weights, mutation_probability = self._normalize_parameters(
-            num_features, num_hidden, weights, mutation_probability)
-        ANN.__init__(self,
-                     num_features=num_features,
-                     num_hidden=num_hidden,
-                     weights=weights)
+        (
+            num_features,
+            num_hidden,
+            weights,
+            mutation_probability,
+        ) = self._normalize_parameters(
+            num_features, num_hidden, weights, mutation_probability
+        )
+        ANN.__init__(
+            self, num_features=num_features, num_hidden=num_hidden, weights=weights
+        )
         EvolvablePlayer.__init__(self)
         self.mutation_probability = mutation_probability
         self.mutation_distance = mutation_distance
         self.overwrite_init_kwargs(
             num_features=num_features,
             num_hidden=num_hidden,
             weights=weights,
-            mutation_probability=mutation_probability)
+            mutation_probability=mutation_probability,
+        )
 
     @classmethod
-    def _normalize_parameters(cls, num_features=None, num_hidden=None, weights=None, mutation_probability=None):
+    def _normalize_parameters(
+        cls, num_features=None, num_hidden=None, weights=None, mutation_probability=None
+    ):
         if not (num_features and num_hidden):
-            raise InsufficientParametersError("Insufficient Parameters to instantiate EvolvableANN")
+            raise InsufficientParametersError(
+                "Insufficient Parameters to instantiate EvolvableANN"
+            )
         size = num_weights(num_features, num_hidden)
         if not weights:
             weights = [random.uniform(-1, 1) for _ in range(size)]
         if mutation_probability is None:
-            mutation_probability = 10. / size
+            mutation_probability = 10.0 / size
         return num_features, num_hidden, weights, mutation_probability
 
     @staticmethod
-    def mutate_weights(weights, num_features, num_hidden, mutation_probability,
-                       mutation_distance):
+    def mutate_weights(
+        weights, num_features, num_hidden, mutation_probability, mutation_distance
+    ):
         size = num_weights(num_features, num_hidden)
         randoms = random.random(size)
         for i, r in enumerate(randoms):
@@ -269,8 +286,12 @@ def mutate_weights(weights, num_features, num_hidden, mutation_probability,
 
     def mutate(self):
         weights = self.mutate_weights(
-            self.weights, self.num_features, self.num_hidden,
-            self.mutation_probability, self.mutation_distance)
+            self.weights,
+            self.num_features,
+            self.num_hidden,
+            self.mutation_probability,
+            self.mutation_distance,
+        )
         return self.create_new(weights=weights)
 
     def crossover(self, other):
@@ -298,9 +319,8 @@ class EvolvedANN(ANN):
     def __init__(self) -> None:
         num_features, num_hidden, weights = nn_weights["Evolved ANN"]
         super().__init__(
-            num_features=num_features,
-            num_hidden=num_hidden,
-            weights=weights)
+            num_features=num_features, num_hidden=num_hidden, weights=weights
+        )
 
 
 class EvolvedANN5(ANN):
@@ -321,9 +341,8 @@ class EvolvedANN5(ANN):
     def __init__(self) -> None:
         num_features, num_hidden, weights = nn_weights["Evolved ANN 5"]
         super().__init__(
-            num_features=num_features,
-            num_hidden=num_hidden,
-            weights=weights)
+            num_features=num_features, num_hidden=num_hidden, weights=weights
+        )
 
 
 class EvolvedANNNoise05(ANN):
@@ -344,7 +363,5 @@ class EvolvedANNNoise05(ANN):
     def __init__(self) -> None:
         num_features, num_hidden, weights = nn_weights["Evolved ANN 5 Noise 05"]
         super().__init__(
-            num_features=num_features,
-            num_hidden=num_hidden,
-            weights=weights)
-
+            num_features=num_features, num_hidden=num_hidden, weights=weights
+        )