Format codebase using black

axelrod/fingerprint.py

@@ -13,8 +13,10 @@
 
 import axelrod as axl
 from axelrod import Player
-from axelrod.interaction_utils import (compute_final_score_per_turn,
-                                       read_interactions_from_file)
+from axelrod.interaction_utils import (
+    compute_final_score_per_turn,
+    read_interactions_from_file,
+)
 from axelrod.strategy_transformers import DualTransformer, JossAnnTransformer
 
 Point = namedtuple("Point", "x y")

axelrod/game.py

@@ -30,11 +30,7 @@ def __init__(self, r: Score = 3, s: Score = 0, t: Score = 5, p: Score = 1) -> No
         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/moran.py

@@ -51,7 +51,7 @@ def __init__(
         noise: float = 0,
         game: Game = None,
         deterministic_cache: DeterministicCache = None,
-        mutation_rate: float = 0.,
+        mutation_rate: float = 0.0,
         mode: str = "bd",
         interaction_graph: Graph = None,
         reproduction_graph: Graph = None,

axelrod/strategies/_strategies.py

@@ -4,89 +4,225 @@
 from .apavlov import APavlov2006, APavlov2011
 from .appeaser import Appeaser
 from .averagecopier import AverageCopier, NiceAverageCopier
-from .axelrod_first import (Davis, Feld, Grofman, Joss, Nydegger,
-                            RevisedDowning, Shubik, SteinAndRapoport,
-                            TidemanAndChieruzzi, Tullock, UnnamedStrategy)
-from .axelrod_second import (Black, Borufsen, Cave, Champion, Colbert,
-                             Eatherley, Getzler, Gladstein, GraaskampKatzen,
-                             Harrington, Kluepfel, Leyvraz, Mikkelson,
-                             MoreGrofman, MoreTidemanAndChieruzzi,
-                             RichardHufford, Tester, Tranquilizer, Weiner,
-                             White, WmAdams, Yamachi)
+from .axelrod_first import (
+    Davis,
+    Feld,
+    Grofman,
+    Joss,
+    Nydegger,
+    RevisedDowning,
+    Shubik,
+    SteinAndRapoport,
+    TidemanAndChieruzzi,
+    Tullock,
+    UnnamedStrategy,
+)
+from .axelrod_second import (
+    Black,
+    Borufsen,
+    Cave,
+    Champion,
+    Colbert,
+    Eatherley,
+    Getzler,
+    Gladstein,
+    GraaskampKatzen,
+    Harrington,
+    Kluepfel,
+    Leyvraz,
+    Mikkelson,
+    MoreGrofman,
+    MoreTidemanAndChieruzzi,
+    RichardHufford,
+    Tester,
+    Tranquilizer,
+    Weiner,
+    White,
+    WmAdams,
+    Yamachi,
+)
 from .backstabber import BackStabber, DoubleCrosser
 from .better_and_better import BetterAndBetter
 from .bush_mosteller import BushMosteller
 from .calculator import Calculator
 from .cooperator import Cooperator, TrickyCooperator
-from .cycler import (AntiCycler, Cycler, CyclerCCCCCD, CyclerCCCD,
-                     CyclerCCCDCD, CyclerCCD, CyclerDC, CyclerDDC)
+from .cycler import (
+    AntiCycler,
+    Cycler,
+    CyclerCCCCCD,
+    CyclerCCCD,
+    CyclerCCCDCD,
+    CyclerCCD,
+    CyclerDC,
+    CyclerDDC,
+)
 from .darwin import Darwin
 from .dbs import DBS
 from .defector import Defector, TrickyDefector
 from .doubler import Doubler
-from .finite_state_machines import (TF1, TF2, TF3, EvolvedFSM4, EvolvedFSM16,
-                                    EvolvedFSM16Noise05, Fortress3, Fortress4,
-                                    FSMPlayer, Predator, Pun1, Raider, Ripoff,
-                                    SolutionB1, SolutionB5, Thumper)
+from .finite_state_machines import (
+    TF1,
+    TF2,
+    TF3,
+    EvolvedFSM4,
+    EvolvedFSM16,
+    EvolvedFSM16Noise05,
+    Fortress3,
+    Fortress4,
+    FSMPlayer,
+    Predator,
+    Pun1,
+    Raider,
+    Ripoff,
+    SolutionB1,
+    SolutionB5,
+    Thumper,
+)
 from .forgiver import Forgiver, ForgivingTitForTat
-from .gambler import (Gambler, PSOGambler1_1_1, PSOGambler2_2_2,
-                      PSOGambler2_2_2_Noise05, PSOGamblerMem1, ZDMem2)
+from .gambler import (
+    Gambler,
+    PSOGambler1_1_1,
+    PSOGambler2_2_2,
+    PSOGambler2_2_2_Noise05,
+    PSOGamblerMem1,
+    ZDMem2,
+)
 from .geller import Geller, GellerCooperator, GellerDefector
-from .gobymajority import (GoByMajority, GoByMajority5, GoByMajority10,
-                           GoByMajority20, GoByMajority40, HardGoByMajority,
-                           HardGoByMajority5, HardGoByMajority10,
-                           HardGoByMajority20, HardGoByMajority40)
+from .gobymajority import (
+    GoByMajority,
+    GoByMajority5,
+    GoByMajority10,
+    GoByMajority20,
+    GoByMajority40,
+    HardGoByMajority,
+    HardGoByMajority5,
+    HardGoByMajority10,
+    HardGoByMajority20,
+    HardGoByMajority40,
+)
 from .gradualkiller import GradualKiller
-from .grudger import (Aggravater, EasyGo, ForgetfulGrudger, GeneralSoftGrudger,
-                      Grudger, GrudgerAlternator, OppositeGrudger, SoftGrudger)
+from .grudger import (
+    Aggravater,
+    EasyGo,
+    ForgetfulGrudger,
+    GeneralSoftGrudger,
+    Grudger,
+    GrudgerAlternator,
+    OppositeGrudger,
+    SoftGrudger,
+)
 from .grumpy import Grumpy
 from .handshake import Handshake
 from .hmm import EvolvedHMM5, HMMPlayer
 from .human import Human
-from .hunter import (AlternatorHunter, CooperatorHunter, CycleHunter,
-                     DefectorHunter, EventualCycleHunter, MathConstantHunter,
-                     RandomHunter)
+from .hunter import (
+    AlternatorHunter,
+    CooperatorHunter,
+    CycleHunter,
+    DefectorHunter,
+    EventualCycleHunter,
+    MathConstantHunter,
+    RandomHunter,
+)
 from .inverse import Inverse
-from .lookerup import (EvolvedLookerUp1_1_1, EvolvedLookerUp2_2_2, LookerUp,
-                       Winner12, Winner21)
+from .lookerup import (
+    EvolvedLookerUp1_1_1,
+    EvolvedLookerUp2_2_2,
+    LookerUp,
+    Winner12,
+    Winner21,
+)
 from .mathematicalconstants import Golden, Pi, e
-from .memoryone import (GTFT, ALLCorALLD, FirmButFair, MemoryOnePlayer,
-                        ReactivePlayer, SoftJoss, StochasticCooperator,
-                        StochasticWSLS, WinShiftLoseStay, WinStayLoseShift)
+from .memoryone import (
+    GTFT,
+    ALLCorALLD,
+    FirmButFair,
+    MemoryOnePlayer,
+    ReactivePlayer,
+    SoftJoss,
+    StochasticCooperator,
+    StochasticWSLS,
+    WinShiftLoseStay,
+    WinStayLoseShift,
+)
 from .memorytwo import AON2, MEM2, DelayedAON1, MemoryTwoPlayer
 from .mindcontrol import MindBender, MindController, MindWarper
 from .mindreader import MindReader, MirrorMindReader, ProtectedMindReader
 from .mutual import Desperate, Hopeless, Willing
 from .negation import Negation
-from .oncebitten import (FoolMeForever, FoolMeOnce, ForgetfulFoolMeOnce,
-                         OnceBitten)
-from .prober import (CollectiveStrategy, HardProber, NaiveProber, Prober,
-                     Prober2, Prober3, Prober4, RemorsefulProber)
-from .punisher import (InversePunisher, LevelPunisher, Punisher,
-                       TrickyLevelPunisher)
-from .qlearner import (ArrogantQLearner, CautiousQLearner, HesitantQLearner,
-                       RiskyQLearner)
+from .oncebitten import FoolMeForever, FoolMeOnce, ForgetfulFoolMeOnce, OnceBitten
+from .prober import (
+    CollectiveStrategy,
+    HardProber,
+    NaiveProber,
+    Prober,
+    Prober2,
+    Prober3,
+    Prober4,
+    RemorsefulProber,
+)
+from .punisher import InversePunisher, LevelPunisher, Punisher, TrickyLevelPunisher
+from .qlearner import (
+    ArrogantQLearner,
+    CautiousQLearner,
+    HesitantQLearner,
+    RiskyQLearner,
+)
 from .rand import Random
 from .resurrection import DoubleResurrection, Resurrection
-from .retaliate import (LimitedRetaliate, LimitedRetaliate2, LimitedRetaliate3,
-                        Retaliate, Retaliate2, Retaliate3)
+from .retaliate import (
+    LimitedRetaliate,
+    LimitedRetaliate2,
+    LimitedRetaliate3,
+    Retaliate,
+    Retaliate2,
+    Retaliate3,
+)
 from .selfsteem import SelfSteem
 from .sequence_player import SequencePlayer, ThueMorse, ThueMorseInverse
 from .shortmem import ShortMem
 from .stalker import Stalker
-from .titfortat import (AdaptiveTitForTat, Alexei, AntiTitForTat, Bully,
-                        ContriteTitForTat, DynamicTwoTitsForTat, EugineNier,
-                        Gradual, HardTitFor2Tats, HardTitForTat, Michaelos,
-                        NTitsForMTats, OmegaTFT, RandomTitForTat,
-                        SlowTitForTwoTats2, SneakyTitForTat, SpitefulTitForTat,
-                        SuspiciousTitForTat, TitFor2Tats, TitForTat,
-                        TwoTitsForTat)
+from .titfortat import (
+    AdaptiveTitForTat,
+    Alexei,
+    AntiTitForTat,
+    Bully,
+    ContriteTitForTat,
+    DynamicTwoTitsForTat,
+    EugineNier,
+    Gradual,
+    HardTitFor2Tats,
+    HardTitForTat,
+    Michaelos,
+    NTitsForMTats,
+    OmegaTFT,
+    RandomTitForTat,
+    SlowTitForTwoTats2,
+    SneakyTitForTat,
+    SpitefulTitForTat,
+    SuspiciousTitForTat,
+    TitFor2Tats,
+    TitForTat,
+    TwoTitsForTat,
+)
 from .verybad import VeryBad
-from .worse_and_worse import (KnowledgeableWorseAndWorse, WorseAndWorse,
-                              WorseAndWorse2, WorseAndWorse3)
-from .zero_determinant import (ZDGTFT2, ZDExtort2, ZDExtort2v2, ZDExtort3,
-                               ZDExtort4, ZDExtortion, ZDGen2, ZDMischief,
-                               ZDSet2)
+from .worse_and_worse import (
+    KnowledgeableWorseAndWorse,
+    WorseAndWorse,
+    WorseAndWorse2,
+    WorseAndWorse3,
+)
+from .zero_determinant import (
+    ZDGTFT2,
+    ZDExtort2,
+    ZDExtort2v2,
+    ZDExtort3,
+    ZDExtort4,
+    ZDExtortion,
+    ZDGen2,
+    ZDMischief,
+    ZDSet2,
+)
 
 # Note: Meta* strategies are handled in .__init__.py
 

axelrod/strategies/axelrod_second.py

@@ -389,7 +389,7 @@ def strategy(self, opponent: Player) -> Action:
         if (current_score[0] / ((len(self.history)) + 1)) >= 2.25:
             probability = (
                 (
-                    .95
+                    0.95
                     - (
                         (
                             (self.one_turn_after_good_defection_ratio)
@@ -408,8 +408,8 @@ def strategy(self, opponent: Player) -> Action:
             return D
         if (current_score[0] / ((len(self.history)) + 1)) >= 1.75:
             probability = (
-                (.25 + ((opponent.cooperations + 1) / ((len(self.history)) + 1)))
-                - (self.opponent_consecutive_defections * .25)
+                (0.25 + ((opponent.cooperations + 1) / ((len(self.history)) + 1)))
+                - (self.opponent_consecutive_defections * 0.25)
                 + ((current_score[0] - current_score[1]) / 100)
                 + (4 / ((len(self.history)) + 1))
             )

axelrod/strategies/dbs.py

@@ -34,7 +34,7 @@ class DBS(Player):
 
     def __init__(
         self,
-        discount_factor=.75,
+        discount_factor=0.75,
         promotion_threshold=3,
         violation_threshold=4,
         reject_threshold=3,

axelrod/strategies/hmm.py

@@ -16,7 +16,7 @@ def is_stochastic_matrix(m, ep=1e-8) -> bool:
             if (m[i][j] < 0) or (m[i][j] > 1):
                 return False
         s = sum(m[i])
-        if abs(1. - s) > ep:
+        if abs(1.0 - s) > ep:
             return False
     return True
 

axelrod/strategies/memoryone.py

@@ -257,7 +257,7 @@ def __init__(self, ep: float = 0.05) -> None:
         """
 
         self.ep = ep
-        four_vector = (1. - ep, ep, ep, 1. - ep)
+        four_vector = (1.0 - ep, ep, ep, 1.0 - ep)
         super().__init__(four_vector)
         self.set_four_vector(four_vector)
 
@@ -287,7 +287,7 @@ def __init__(self, q: float = 0.9) -> None:
         TitForTat  is equivalent to SoftJoss(1)
         """
         self.q = q
-        four_vector = (1., 1 - q, 1, 1 - q)
+        four_vector = (1.0, 1 - q, 1, 1 - q)
         super().__init__(four_vector)
 
     def __repr__(self) -> str:

axelrod/strategies/meta.py

@@ -7,9 +7,15 @@
 from numpy.random import choice
 
 from ._strategies import all_strategies
-from .hunter import (AlternatorHunter, CooperatorHunter, CycleHunter,
-                     DefectorHunter, EventualCycleHunter, MathConstantHunter,
-                     RandomHunter)
+from .hunter import (
+    AlternatorHunter,
+    CooperatorHunter,
+    CycleHunter,
+    DefectorHunter,
+    EventualCycleHunter,
+    MathConstantHunter,
+    RandomHunter,
+)
 
 # Needs to be computed manually to prevent circular dependency
 ordinary_strategies = [s for s in all_strategies if obey_axelrod(s)]