fixed import statements

Author: sudarshan-parvatikar

axelrod/tests/unit/test_interaction_utils.py

@@ -3,7 +3,6 @@
 from collections import Counter
 
 import axelrod as axl
-import axelrod.interaction_utils as iu
 
 C, D = axl.Action.C, axl.Action.D
 
@@ -46,43 +45,43 @@ class TestMatch(unittest.TestCase):
 
     def test_compute_scores(self):
         for inter, score in zip(self.interactions, self.scores):
-            self.assertEqual(score, iu.compute_scores(inter))
+            self.assertEqual(score, axl.interaction_utils.compute_scores(inter))
 
     def test_compute_final_score(self):
         for inter, final_score in zip(self.interactions, self.final_scores):
-            self.assertEqual(final_score, iu.compute_final_score(inter))
+            self.assertEqual(final_score, axl.interaction_utils.compute_final_score(inter))
 
     def test_compute_final_score_per_turn(self):
         for inter, final_score_per_round in zip(
             self.interactions, self.final_score_per_turn
         ):
             self.assertEqual(
-                final_score_per_round, iu.compute_final_score_per_turn(inter)
+                final_score_per_round, axl.interaction_utils.compute_final_score_per_turn(inter)
             )
 
     def test_compute_winner_index(self):
         for inter, winner in zip(self.interactions, self.winners):
-            self.assertEqual(winner, iu.compute_winner_index(inter))
+            self.assertEqual(winner, axl.interaction_utils.compute_winner_index(inter))
 
     def test_compute_cooperations(self):
         for inter, coop in zip(self.interactions, self.cooperations):
-            self.assertEqual(coop, iu.compute_cooperations(inter))
+            self.assertEqual(coop, axl.interaction_utils.compute_cooperations(inter))
 
     def test_compute_normalised_cooperations(self):
         for inter, coop in zip(self.interactions, self.normalised_cooperations):
-            self.assertEqual(coop, iu.compute_normalised_cooperation(inter))
+            self.assertEqual(coop, axl.interaction_utils.compute_normalised_cooperation(inter))
 
     def test_compute_state_distribution(self):
         for inter, dist in zip(self.interactions, self.state_distribution):
-            self.assertEqual(dist, iu.compute_state_distribution(inter))
+            self.assertEqual(dist, axl.interaction_utils.compute_state_distribution(inter))
 
     def test_compute_normalised_state_distribution(self):
         for inter, dist in zip(self.interactions, self.normalised_state_distribution):
-            self.assertEqual(dist, iu.compute_normalised_state_distribution(inter))
+            self.assertEqual(dist, axl.interaction_utils.compute_normalised_state_distribution(inter))
 
     def test_compute_state_to_action_distribution(self):
         for inter, dist in zip(self.interactions, self.state_to_action_distribution):
-            self.assertEqual(dist, iu.compute_state_to_action_distribution(inter))
+            self.assertEqual(dist, axl.interaction_utils.compute_state_to_action_distribution(inter))
         inter = [(C, D), (D, C), (C, D), (D, C), (D, D), (C, C), (C, D)]
         expected_dist = [
             Counter(
@@ -97,14 +96,14 @@ def test_compute_state_to_action_distribution(self):
             Counter({((C, C), D): 1, ((C, D), C): 2, ((D, C), D): 2, ((D, D), C): 1}),
         ]
 
-        self.assertEqual(expected_dist, iu.compute_state_to_action_distribution(inter))
+        self.assertEqual(expected_dist, axl.interaction_utils.compute_state_to_action_distribution(inter))
 
     def test_compute_normalised_state_to_action_distribution(self):
         for inter, dist in zip(
             self.interactions, self.normalised_state_to_action_distribution
         ):
             self.assertEqual(
-                dist, iu.compute_normalised_state_to_action_distribution(inter)
+                dist, axl.interaction_utils.compute_normalised_state_to_action_distribution(inter)
             )
         inter = [(C, D), (D, C), (C, D), (D, C), (D, D), (C, C), (C, D)]
         expected_dist = [
@@ -120,12 +119,12 @@ def test_compute_normalised_state_to_action_distribution(self):
             Counter({((C, C), D): 1, ((C, D), C): 1, ((D, C), D): 1, ((D, D), C): 1}),
         ]
         self.assertEqual(
-            expected_dist, iu.compute_normalised_state_to_action_distribution(inter)
+            expected_dist, axl.interaction_utils.compute_normalised_state_to_action_distribution(inter)
         )
 
     def test_compute_sparklines(self):
         for inter, spark in zip(self.interactions, self.sparklines):
-            self.assertEqual(spark, iu.compute_sparklines(inter))
+            self.assertEqual(spark, axl.interaction_utils.compute_sparklines(inter))
 
     def test_read_interactions_from_file(self):
         tmp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
@@ -138,10 +137,10 @@ def test_read_interactions_from_file(self):
             (0, 1): [[(C, D), (C, D)] for _ in range(3)],
             (1, 1): [[(D, D), (D, D)] for _ in range(3)],
         }
-        interactions = iu.read_interactions_from_file(tmp_file.name, progress_bar=False)
+        interactions = axl.interaction_utils.read_interactions_from_file(tmp_file.name, progress_bar=False)
         self.assertEqual(expected_interactions, interactions)
 
     def test_string_to_interactions(self):
         string = "CDCDDD"
         interactions = [(C, D), (C, D), (D, D)]
-        self.assertEqual(iu.string_to_interactions(string), interactions)
+        self.assertEqual(axl.interaction_utils.string_to_interactions(string), interactions)