refactored import statements to 'import axelrod as axl' axelrod/tests/unit/*

Author: sudarshan-parvatikar

axelrod/tests/unit/test_actions.py

@@ -1,9 +1,9 @@
 import unittest
 
-from axelrod import Action
+import axelrod as axl
 from axelrod.action import UnknownActionError, actions_to_str, str_to_actions
 
-C, D = Action.C, Action.D
+C, D = axl.Action.C, axl.Action.D
 
 
 class TestAction(unittest.TestCase):
@@ -34,8 +34,8 @@ def test_flip(self):
         self.assertEqual(D.flip(), C)
 
     def test_from_char(self):
-        self.assertEqual(Action.from_char("C"), C)
-        self.assertEqual(Action.from_char("D"), D)
+        self.assertEqual(axl.Action.from_char("C"), C)
+        self.assertEqual(axl.Action.from_char("D"), D)
 
     def test_from_char_error(self):
         self.assertRaises(UnknownActionError, Action.from_char, "")

axelrod/tests/unit/test_compute_finite_state_machine_memory.py

@@ -1,10 +1,11 @@
 """Tests for Compute FSM Memory."""
-import axelrod
+
 import unittest
 
+import axelrod as axl
 from axelrod.compute_finite_state_machine_memory import *
 
-C, D = axelrod.Action.C, axelrod.Action.D
+C, D = axl.Action.C, axl.Action.D
 
 
 class TestOrderedMemitTuple(unittest.TestCase):

axelrod/tests/unit/test_deterministic_cache.py

@@ -1,16 +1,18 @@
+import unittest
+
 import os
+
 import pickle
-import unittest
 
-from axelrod import Action, Defector, DeterministicCache, Random, TitForTat
+import axelrod as axl
 
-C, D = Action.C, Action.D
+C, D = axl.Action.C, axl.Action.D
 
 
 class TestDeterministicCache(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.test_key = (TitForTat(), Defector())
+        cls.test_key = (axl.TitForTat(), axl.Defector())
         cls.test_value = [(C, D), (D, D), (D, D)]
         cls.test_save_file = "test_cache_save.txt"
         cls.test_load_file = "test_cache_load.txt"
@@ -26,13 +28,13 @@ def tearDownClass(cls):
         os.remove(cls.test_load_file)
 
     def setUp(self):
-        self.cache = DeterministicCache()
+        self.cache = axl.DeterministicCache()
 
     def test_basic_init(self):
         self.assertTrue(self.cache.mutable)
 
     def test_init_from_file(self):
-        loaded_cache = DeterministicCache(file_name=self.test_load_file)
+        loaded_cache = axl.DeterministicCache(file_name=self.test_load_file)
         self.assertEqual(loaded_cache[self.test_key], self.test_value)
 
     def test_setitem(self):
@@ -49,25 +51,25 @@ def test_setitem_invalid_key_first_two_elements_not_player(self):
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-        invalid_key = (TitForTat(), "test")
+        invalid_key = (axl.TitForTat(), "test")
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-        invalid_key = ("test", TitForTat())
+        invalid_key = ("test", axl.TitForTat())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
     def test_setitem_invalid_key_too_many_players(self):
-        invalid_key = (TitForTat(), TitForTat(), TitForTat())
+        invalid_key = (axl.TitForTat(), axl.TitForTat(), axl.TitForTat())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
     def test_setitem_invalid_key_stochastic_player(self):
-        invalid_key = (Random(), TitForTat())
+        invalid_key = (axl.Random(), axl.TitForTat())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-        invalid_key = (TitForTat(), Random())
+        invalid_key = (axl.TitForTat(), axl.Random())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 

axelrod/tests/unit/test_ecosystem.py

@@ -2,33 +2,33 @@
 
 import unittest
 
-import axelrod
+import axelrod as axl
 
 
 class TestEcosystem(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cooperators = axelrod.Tournament(
+        cooperators = axl.Tournament(
             players=[
-                axelrod.Cooperator(),
-                axelrod.Cooperator(),
-                axelrod.Cooperator(),
-                axelrod.Cooperator(),
+                axl.Cooperator(),
+                axl.Cooperator(),
+                axl.Cooperator(),
+                axl.Cooperator(),
             ]
         )
-        defector_wins = axelrod.Tournament(
+        defector_wins = axl.Tournament(
             players=[
-                axelrod.Cooperator(),
-                axelrod.Cooperator(),
-                axelrod.Cooperator(),
-                axelrod.Defector(),
+                axl.Cooperator(),
+                axl.Cooperator(),
+                axl.Cooperator(),
+                axl.Defector(),
             ]
         )
         cls.res_cooperators = cooperators.play()
         cls.res_defector_wins = defector_wins.play()
 
     def test_default_population_sizes(self):
-        eco = axelrod.Ecosystem(self.res_cooperators)
+        eco = axl.Ecosystem(self.res_cooperators)
         pops = eco.population_sizes
         self.assertEqual(eco.num_players, 4)
         self.assertEqual(len(pops), 1)
@@ -37,7 +37,7 @@ def test_default_population_sizes(self):
         self.assertEqual(list(set(pops[0])), [0.25])
 
     def test_non_default_population_sizes(self):
-        eco = axelrod.Ecosystem(
+        eco = axl.Ecosystem(
             self.res_cooperators, population=[0.7, 0.25, 0.03, 0.02]
         )
         pops = eco.population_sizes
@@ -48,7 +48,7 @@ def test_non_default_population_sizes(self):
         self.assertEqual(pops[0], [0.7, 0.25, 0.03, 0.02])
 
     def test_population_normalization(self):
-        eco = axelrod.Ecosystem(self.res_cooperators, population=[70, 25, 3, 2])
+        eco = axl.Ecosystem(self.res_cooperators, population=[70, 25, 3, 2])
         pops = eco.population_sizes
         self.assertEqual(eco.num_players, 4)
         self.assertEqual(len(pops), 1)
@@ -59,26 +59,26 @@ def test_population_normalization(self):
     def test_results_and_population_of_different_sizes(self):
         self.assertRaises(
             TypeError,
-            axelrod.Ecosystem,
+            axl.Ecosystem,
             self.res_cooperators,
             population=[0.7, 0.2, 0.03, 0.1, 0.1],
         )
 
     def test_negative_populations(self):
         self.assertRaises(
             TypeError,
-            axelrod.Ecosystem,
+            axl.Ecosystem,
             self.res_cooperators,
             population=[0.7, -0.2, 0.03, 0.2],
         )
 
     def test_fitness_function(self):
         fitness = lambda p: 2 * p
-        eco = axelrod.Ecosystem(self.res_cooperators, fitness=fitness)
+        eco = axl.Ecosystem(self.res_cooperators, fitness=fitness)
         self.assertTrue(eco.fitness(10), 20)
 
     def test_cooperators_are_stable_over_time(self):
-        eco = axelrod.Ecosystem(self.res_cooperators)
+        eco = axl.Ecosystem(self.res_cooperators)
         eco.reproduce(100)
         pops = eco.population_sizes
         self.assertEqual(len(pops), 101)
@@ -88,7 +88,7 @@ def test_cooperators_are_stable_over_time(self):
             self.assertEqual(list(set(p)), [0.25])
 
     def test_defector_wins_with_only_cooperators(self):
-        eco = axelrod.Ecosystem(self.res_defector_wins)
+        eco = axl.Ecosystem(self.res_defector_wins)
         eco.reproduce(1000)
         pops = eco.population_sizes
         self.assertEqual(len(pops), 1001)

axelrod/tests/unit/test_eigen.py

@@ -3,9 +3,11 @@
 import unittest
 
 import numpy
-from axelrod.eigen import _normalise, principal_eigenvector
 from numpy.testing import assert_array_almost_equal
 
+from axelrod.eigen import _normalise, principal_eigenvector
+
+
 
 class FunctionCases(unittest.TestCase):
     def test_identity_matrices(self):

axelrod/tests/unit/test_filters.py

@@ -1,6 +1,6 @@
 import unittest
 
-from axelrod import filtered_strategies
+import axelrod as axl
 from axelrod.strategies._filters import *
 
 from hypothesis import example, given, settings
@@ -156,14 +156,14 @@ class UsesLengthTestStrategy(object):
         uses_length_filterset = {"stochastic": True, "makes_use_of": ["length"]}
 
         self.assertEqual(
-            filtered_strategies(stochastic_filterset, strategies),
+            axl.filtered_strategies(stochastic_filterset, strategies),
             [StochasticTestStrategy, UsesLengthTestStrategy],
         )
         self.assertEqual(
-            filtered_strategies(deterministic_filterset, strategies),
+            axl.filtered_strategies(deterministic_filterset, strategies),
             [MemoryDepth2TestStrategy],
         )
         self.assertEqual(
-            filtered_strategies(uses_length_filterset, strategies),
+            axl.filtered_strategies(uses_length_filterset, strategies),
             [UsesLengthTestStrategy],
         )

axelrod/tests/unit/test_fingerprint.py

@@ -1,17 +1,22 @@
-import os
 import unittest
-from tempfile import mkstemp
 from unittest.mock import patch
 
+import os
+
+from tempfile import mkstemp
+
 import matplotlib.pyplot
+
 import numpy as np
-from hypothesis import given, settings
 
 import axelrod as axl
 from axelrod.fingerprint import AshlockFingerprint, Point, TransitiveFingerprint
 from axelrod.strategy_transformers import DualTransformer, JossAnnTransformer
 from axelrod.tests.property import strategy_lists
 
+from hypothesis import given, settings
+
+
 C, D = axl.Action.C, axl.Action.D
 
 

axelrod/tests/unit/test_game.py

@@ -1,12 +1,12 @@
 import unittest
 
-from axelrod import Action, Game
+import axelrod as axl
 from axelrod.tests.property import games
 
 from hypothesis import given, settings
 from hypothesis.strategies import integers
 
-C, D = Action.C, Action.D
+C, D = axl.Action.C, axl.Action.D
 
 
 class TestGame(unittest.TestCase):
@@ -17,29 +17,29 @@ def test_default_scores(self):
             (D, D): (1, 1),
             (C, C): (3, 3),
         }
-        self.assertEqual(Game().scores, expected_scores)
+        self.assertEqual(axl.Game().scores, expected_scores)
 
     def test_default_RPST(self):
         expected_values = (3, 1, 0, 5)
-        self.assertEqual(Game().RPST(), expected_values)
+        self.assertEqual(axl.Game().RPST(), expected_values)
 
     def test_default_score(self):
-        game = Game()
+        game = axl.Game()
         self.assertEqual(game.score((C, C)), (3, 3))
         self.assertEqual(game.score((D, D)), (1, 1))
         self.assertEqual(game.score((C, D)), (0, 5))
         self.assertEqual(game.score((D, C)), (5, 0))
 
     def test_default_equality(self):
-        self.assertEqual(Game(), Game())
+        self.assertEqual(axl.Game(), axl.Game())
 
     def test_not_default_equality(self):
-        self.assertEqual(Game(1, 2, 3, 4), Game(1, 2, 3, 4))
-        self.assertNotEqual(Game(1, 2, 3, 4), Game(1, 2, 3, 5))
-        self.assertNotEqual(Game(1, 2, 3, 4), Game())
+        self.assertEqual(axl.Game(1, 2, 3, 4), axl.Game(1, 2, 3, 4))
+        self.assertNotEqual(axl.Game(1, 2, 3, 4), axl.Game(1, 2, 3, 5))
+        self.assertNotEqual(axl.Game(1, 2, 3, 4), axl.Game())
 
     def test_wrong_class_equality(self):
-        self.assertNotEqual(Game(), "wrong class")
+        self.assertNotEqual(axl.Game(), "wrong class")
 
     @given(r=integers(), p=integers(), s=integers(), t=integers())
     @settings(max_examples=5)
@@ -51,21 +51,21 @@ def test_random_init(self, r, p, s, t):
             (D, D): (p, p),
             (C, C): (r, r),
         }
-        game = Game(r, s, t, p)
+        game = axl.Game(r, s, t, p)
         self.assertEqual(game.scores, expected_scores)
 
     @given(r=integers(), p=integers(), s=integers(), t=integers())
     @settings(max_examples=5)
     def test_random_RPST(self, r, p, s, t):
         """Test RPST method with random scores using the hypothesis library."""
-        game = Game(r, s, t, p)
+        game = axl.Game(r, s, t, p)
         self.assertEqual(game.RPST(), (r, p, s, t))
 
     @given(r=integers(), p=integers(), s=integers(), t=integers())
     @settings(max_examples=5)
     def test_random_score(self, r, p, s, t):
         """Test score method with random scores using the hypothesis library."""
-        game = Game(r, s, t, p)
+        game = axl.Game(r, s, t, p)
         self.assertEqual(game.score((C, C)), (r, r))
         self.assertEqual(game.score((D, D)), (p, p))
         self.assertEqual(game.score((C, D)), (s, t))