removed blank line bw import stmts, fixed import issues

Author: sudarshan-parvatikar

axelrod/tests/strategies/test_cycler.py

@@ -1,13 +1,9 @@
 """Tests for the Cycler strategies."""
-
 import unittest
-
 import itertools
-
 import random
 
 import axelrod as axl
-from axelrod import AntiCycler, Cycler, EvolvableCycler
 from axelrod._strategy_utils import detect_cycle
 from axelrod.action import Action, str_to_actions
 from axelrod.evolvable_player import InsufficientParametersError
@@ -34,7 +30,7 @@ class TestAntiCycler(TestPlayer):
 
     def test_has_no_cycles(self):
         test_range = 100
-        player = AntiCycler()
+        player = axl.AntiCycler()
         for _ in range(test_range):
             player.play(axl.Cooperator())
 
@@ -79,7 +75,7 @@ def test_strategy(self):
 
 class TestBasicCycler(TestPlayer):
     name = "Cycler: CCD"
-    player = Cycler
+    player = axl.Cycler
     expected_classifier = {
         "memory_depth": 2,
         "stochastic": False,
@@ -93,8 +89,8 @@ class TestBasicCycler(TestPlayer):
     def test_memory_depth_is_len_cycle_minus_one(self):
         len_ten = "DCDCDDCDCD"
         len_five = "DCDDC"
-        depth_nine = Cycler(cycle=len_ten)
-        depth_four = Cycler(cycle=len_five)
+        depth_nine = axl.Cycler(cycle=len_ten)
+        depth_four = axl.Cycler(cycle=len_five)
         self.assertEqual(depth_nine.classifier["memory_depth"], 9)
         self.assertEqual(depth_four.classifier["memory_depth"], 4)
 
@@ -105,7 +101,7 @@ def test_cycler_works_as_expected(self):
         )
 
     def test_cycle_raises_value_error_on_bad_cycle_str(self):
-        self.assertRaises(ValueError, Cycler, cycle="CdDC")
+        self.assertRaises(ValueError, axl.Cycler, cycle="CdDC")
 
 
 def test_cycler_factory(cycle_str):
@@ -152,7 +148,7 @@ def _get_actions_cycle_against_cooperator(cycle_string: str):
 
 class TestEvolvableCycler(unittest.TestCase):
 
-    player_class = EvolvableCycler
+    player_class = axl.EvolvableCycler
 
     def test_normalized_parameters(self):
         # Must specify at least one of cycle or cycle_length
@@ -204,23 +200,23 @@ def test_crossover_odd_length(self):
 
 class TestEvolvableCycler2(TestEvolvablePlayer):
     name = "EvolvableCycler"
-    player_class = EvolvableCycler
-    parent_class = Cycler
+    player_class = axl.EvolvableCycler
+    parent_class = axl.Cycler
     parent_kwargs = ["cycle"]
     init_parameters = {"cycle_length": 100}
 
 
 class TestEvolvableCycler3(TestEvolvablePlayer):
     name = "EvolvableCycler"
-    player_class = EvolvableCycler
-    parent_class = Cycler
+    player_class = axl.EvolvableCycler
+    parent_class = axl.Cycler
     parent_kwargs = ["cycle"]
     init_parameters = {"cycle": "".join(random.choice(("C", "D")) for _ in range(50)),
                        "mutation_potency": 10}
 
 
 # Substitute EvolvedCycler as a regular Cycler.
-EvolvableCyclerWithDefault = PartialClass(EvolvableCycler, cycle="CCD")
+EvolvableCyclerWithDefault = PartialClass(axl.EvolvableCycler, cycle="CCD")
 
 
 class EvolvableCyclerAsCycler(TestBasicCycler):

axelrod/tests/strategies/test_evolvable_player.py

@@ -1,11 +1,8 @@
 import unittest
-
 import functools
-
 import random
 
 import axelrod as axl
-from axelrod import EvolvablePlayer, seed
 from axelrod.action import Action
 from axelrod.evolvable_player import copy_lists, crossover_lists, crossover_dictionaries
 from .test_player import TestPlayer
@@ -22,7 +19,7 @@ class PartialedClass(cls):
     return PartialedClass
 
 
-class EvolvableTestOpponent(EvolvablePlayer):
+class EvolvableTestOpponent(axl.EvolvablePlayer):
     name = "EvolvableTestOpponent"
 
     def __init__(self, value=None):
@@ -76,13 +73,13 @@ def test_randomization(self):
         """Test that randomization on initialization produces different strategies."""
         if self.init_parameters:
             return
-        seed(0)
+        axl.seed(0)
         player1 = self.player()
-        seed(0)
+        axl.seed(0)
         player2 = self.player()
         self.assertEqual(player1, player2)
         for seed_ in range(2, 20):
-            seed(seed_)
+            axl.seed(seed_)
             player2 = self.player()
             if player1 != player2:
                 return
@@ -93,7 +90,7 @@ def test_mutate_variations(self):
         """Generate many variations to test that mutate produces different strategies."""
         if not self.init_parameters:
             return
-        seed(100)
+        axl.seed(100)
         variants_produced = False
         for _ in range(2, 400):
             player = self.player()
@@ -104,7 +101,7 @@ def test_mutate_variations(self):
 
     def test_mutate_and_clone(self):
         """Test that mutated players clone properly."""
-        seed(0)
+        axl.seed(0)
         player = self.player()
         mutant = player.clone().mutate()
         clone = mutant.clone()
@@ -113,7 +110,7 @@ def test_mutate_and_clone(self):
     def test_crossover(self):
         """Test that crossover produces different strategies."""
         for seed_ in range(20):
-            seed(seed_)
+            axl.seed(seed_)
             players = []
             for _ in range(2):
                 player = self.player()
@@ -135,7 +132,7 @@ def test_crossover_mismatch(self):
 
     def test_serialization(self):
         """Serializing and deserializing should return the original player."""
-        seed(0)
+        axl.seed(0)
         player = self.player()
         serialized = player.serialize_parameters()
         deserialized_player = player.__class__.deserialize_parameters(serialized)
@@ -144,7 +141,7 @@ def test_serialization(self):
 
     def test_serialization_csv(self):
         """Serializing and deserializing should return the original player."""
-        seed(0)
+        axl.seed(0)
         player = self.player()
         serialized = player.serialize_parameters()
         s = "0, 1, {}, 3".format(serialized)

axelrod/tests/strategies/test_memoryone.py

@@ -1,11 +1,8 @@
 """Tests for the Memoryone strategies."""
-
 import unittest
-
 import warnings
 
 import axelrod as axl
-from axelrod import Game
 from axelrod.strategies.memoryone import MemoryOnePlayer
 
 from .test_player import TestPlayer, test_four_vector
@@ -101,7 +98,7 @@ def test_strategy(self):
         )
 
     def test_four_vector(self):
-        (R, P, S, T) = Game().RPST()
+        (R, P, S, T) = axl.Game().RPST()
         p = min(1 - (T - R) / (R - S), (R - P) / (T - P))
         expected_dictionary = {(C, C): 1.0, (C, D): p, (D, C): 1.0, (D, D): p}
         test_four_vector(self, expected_dictionary)

axelrod/tests/strategies/test_player.py

@@ -1,17 +1,11 @@
 import unittest
-
 import itertools
-
 import pickle
-
 import random
-
 import types
-
 import numpy as np
 
 import axelrod as axl
-from axelrod import DefaultGame, Player, LimitedHistory
 from axelrod.player import simultaneous_play
 from axelrod.tests.property import strategy_lists
 
@@ -47,7 +41,7 @@ def defect(*args):
 }
 
 
-class ParameterisedTestPlayer(Player):
+class ParameterisedTestPlayer(axl.Player):
     """A simple Player class for testing init parameters"""
 
     name = "ParameterisedTestPlayer"
@@ -60,7 +54,7 @@ def __init__(self, arg_test1="testing1", arg_test2="testing2"):
 class TestPlayerClass(unittest.TestCase):
 
     name = "Player"
-    player = Player
+    player = axl.Player
     classifier = {"stochastic": False}
 
     def test_play(self):
@@ -115,7 +109,7 @@ def test_noisy_play(self):
         self.assertEqual(player2.history[0], D)
 
     def test_update_history(self):
-        player = Player()
+        player = axl.Player()
         self.assertEqual(player.history, [])
         self.assertEqual(player.cooperations, 0)
         self.assertEqual(player.defections, 0)
@@ -129,7 +123,7 @@ def test_update_history(self):
         self.assertEqual(player.cooperations, 1)
 
     def test_history_assignment(self):
-        player = Player()
+        player = axl.Player()
         with self.assertRaises(AttributeError):
             player.history = []
 
@@ -320,9 +314,9 @@ def test_init_kwargs(self):
         # Test that init_kwargs exist and are empty
         self.assertEqual(self.player().init_kwargs, {})
         # Test that passing a positional argument raises an error
-        self.assertRaises(TypeError, Player, "test")
+        self.assertRaises(TypeError, axl.Player, "test")
         # Test that passing a keyword argument raises an error
-        self.assertRaises(TypeError, Player, arg_test1="test")
+        self.assertRaises(TypeError, axl.Player, arg_test1="test")
 
         # Tests for Players with init parameters
 
@@ -353,7 +347,7 @@ def test_init_kwargs(self):
         self.assertRaises(TypeError, ParameterisedTestPlayer, "other", "other", "other")
 
 
-class TestOpponent(Player):
+class TestOpponent(axl.Player):
     """A player who only exists so we have something to test against"""
 
     name = "TestOpponent"
@@ -376,7 +370,7 @@ def test_initialisation(self):
             player = self.player()
             self.assertEqual(len(player.history), 0)
             self.assertEqual(
-                player.match_attributes, {"length": -1, "game": DefaultGame, "noise": 0}
+                player.match_attributes, {"length": -1, "game": axl.DefaultGame, "noise": 0}
             )
             self.assertEqual(player.cooperations, 0)
             self.assertEqual(player.defections, 0)
@@ -682,8 +676,8 @@ def test_memory(player, opponent, memory_length, seed=0, turns=10):
     # Play with limited history.
     player.reset()
     opponent.reset()
-    player._history = LimitedHistory(memory_length)
-    opponent._history = LimitedHistory(memory_length)
+    player._history = axl.LimitedHistory(memory_length)
+    opponent._history = axl.LimitedHistory(memory_length)
     axl.seed(seed)
     match = axl.Match((player, opponent), turns=turns, reset=False)
     limited_plays = [p[0] for p in match.play()]

axelrod/tests/unit/test_deterministic_cache.py

@@ -1,7 +1,5 @@
 import unittest
-
 import os
-
 import pickle
 
 import axelrod as axl

axelrod/tests/unit/test_interaction_utils.py

@@ -1,7 +1,5 @@
 import unittest
-
 import tempfile
-
 from collections import Counter
 
 import axelrod as axl