Merge pull request #514 from Axelrod-Python/509

Add prob end tournament type to run_axelrod

Author: meatballs

axelrod/__init__.py

@@ -11,8 +11,9 @@
 from .strategies import *
 from .tournament_type import *
 from .tournament import Tournament, ProbEndTournament
-from .tournament_manager import TournamentManager
-from .tournament_manager_factory import TournamentManagerFactory
+from .tournament_manager import TournamentManager, ProbEndTournamentManager
+from .tournament_manager_factory import (TournamentManagerFactory,
+                                         ProbEndTournamentManagerFactory)
 from .result_set import ResultSet
 from .ecosystem import Ecosystem
-from .utils import run_tournaments, setup_logging
+from .utils import run_tournaments, run_prob_end_tournaments, setup_logging

axelrod/tests/integration/test_tournament.py

@@ -1,7 +1,7 @@
 import unittest
 import axelrod
 
-from axelrod.utils import setup_logging, run_tournaments
+from axelrod.utils import setup_logging, run_tournaments, run_prob_end_tournaments
 
 class TestTournament(unittest.TestCase):
 
@@ -96,3 +96,46 @@ def test_utils(self):
                     exclude_cheating=True,
                     exclude_ordinary=True,
                     noise=0)
+
+
+class TestProbEndTournamentManager(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.game = axelrod.Game()
+        cls.players = [s() for s in axelrod.demo_strategies]
+
+    def test_tournament_manager(self):
+        strategies = [s() for s in axelrod.demo_strategies]
+        tm = axelrod.ProbEndTournamentManager("./", False, save_cache=False)
+        tm.add_tournament("test-prob-end", strategies, repetitions=2, prob_end=.5,
+                          noise=0.05)
+        tm.run_tournaments()
+
+        strategies = [s() for s in axelrod.basic_strategies]
+        tm = axelrod.ProbEndTournamentManager("./", False, load_cache=False,
+                                              save_cache=True)
+        tm.add_tournament("test-prob-end", strategies, repetitions=2,
+                          prob_end=.5, noise=0.)
+        tm.run_tournaments()
+
+        tm = axelrod.ProbEndTournamentManager("./", False, load_cache=True,
+                                              save_cache=True)
+        tm.add_tournament("test-prob-end", strategies, repetitions=2,
+                          prob_end=.5, noise=0.)
+        tm.run_tournaments()
+
+    def test_utils(self):
+        setup_logging(logging_destination="none")
+        run_prob_end_tournaments(cache_file='./cache.txt',
+                                 output_directory='./',
+                                 repetitions=2,
+                                 prob_end=.5,
+                                 processes=None,
+                                 no_ecological=False,
+                                 rebuild_cache=False,
+                                 exclude_combined=True,
+                                 exclude_basic=False,
+                                 exclude_cheating=True,
+                                 exclude_ordinary=True,
+                                 noise=0)

axelrod/tests/unit/test_tournament_manager.py

@@ -15,9 +15,10 @@ def setUpClass(cls):
         cls.test_players = [axelrod.Defector(), axelrod.Cooperator()]
 
         cls.expected_output_file_path = './assets/test_file_name.png'
+        cls.mgr_class = axelrod.TournamentManager
 
     def test_init(self):
-        mgr = axelrod.TournamentManager(
+        mgr = self.mgr_class(
             self.test_output_directory,
             self.test_with_ecological)
         self.assertEqual(mgr._output_directory, self.test_output_directory)
@@ -26,23 +27,23 @@ def test_init(self):
         self.assertTrue(mgr._pass_cache)
 
     def test_one_player_per_strategy(self):
-        mgr = axelrod.TournamentManager(
+        mgr = self.mgr_class(
             self.test_output_directory,
             self.test_with_ecological)
         players = mgr.one_player_per_strategy(self.test_strategies)
         self.assertIsInstance(players[0], axelrod.Defector)
         self.assertIsInstance(players[1], axelrod.Cooperator)
 
     def test_output_file_path(self):
-        mgr = axelrod.TournamentManager(
+        mgr = self.mgr_class(
             self.test_output_directory,
             self.test_with_ecological)
         output_file_path = mgr._output_file_path(
             self.test_file_name, self.test_file_extenstion)
         self.assertEqual(output_file_path, self.expected_output_file_path)
 
     def test_add_tournament(self):
-        mgr = axelrod.TournamentManager(
+        mgr = self.mgr_class(
             self.test_output_directory,
             self.test_with_ecological)
         mgr.add_tournament(
@@ -52,7 +53,7 @@ def test_add_tournament(self):
         self.assertEqual(mgr._tournaments[0].name, self.test_tournament_name)
 
     def test_valid_cache(self):
-        mgr = axelrod.TournamentManager(
+        mgr = self.mgr_class(
             output_directory=self.test_output_directory,
             with_ecological=self.test_with_ecological, load_cache=False)
         mgr.add_tournament(
@@ -67,10 +68,47 @@ def test_valid_cache(self):
     def test_tournament_label(self):
         tournament = axelrod.Tournament(self.test_players, turns=20,
                                         repetitions=2)
-        mgr = axelrod.TournamentManager(
+        mgr = self.mgr_class(
             output_directory=self.test_output_directory,
             with_ecological=self.test_with_ecological, load_cache=False)
         expected_label = "Turns: {}, Repetitions: {}, Strategies: {}.".format(tournament.turns,
                 tournament.repetitions, len(tournament.players))
 
         self.assertEqual(mgr._tournament_label(tournament), expected_label)
+
+
+class TestProbEndTournamentManager(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.test_output_directory = './assets/'
+        cls.test_with_ecological = True
+        cls.test_tournament_name = 'test_prob_tournament'
+        cls.test_file_name = 'test_prob_end_file_name'
+        cls.test_file_extenstion = 'png'
+        cls.test_strategies = [axelrod.Defector, axelrod.Cooperator]
+        cls.test_players = [axelrod.Defector(), axelrod.Cooperator()]
+
+        cls.expected_output_file_path = './assets/test__prob_end_file_name.png'
+        cls.mgr_class = axelrod.ProbEndTournamentManager
+
+    def test_add_tournament(self):
+        mgr = self.mgr_class(
+            self.test_output_directory,
+            self.test_with_ecological)
+        mgr.add_tournament(
+            players=self.test_players, name=self.test_tournament_name)
+        self.assertEqual(len(mgr._tournaments), 1)
+        self.assertIsInstance(mgr._tournaments[0], axelrod.ProbEndTournament)
+        self.assertEqual(mgr._tournaments[0].name, self.test_tournament_name)
+
+    def test_tournament_label(self):
+        tournament = axelrod.ProbEndTournament(self.test_players, prob_end=.5,
+                                               repetitions=2)
+        mgr = self.mgr_class(
+            output_directory=self.test_output_directory,
+            with_ecological=self.test_with_ecological, load_cache=False)
+        expected_label = "Prob end: {}, Repetitions: {}, Strategies: {}.".format(tournament.prob_end,
+                    tournament.repetitions,
+                    len(tournament.players))
+        self.assertEqual(mgr._tournament_label(tournament), expected_label)

axelrod/tests/unit/test_tournament_manager_factory.py

@@ -21,10 +21,10 @@ def setUpClass(cls):
         }
 
         cls.expected_basic_strategies = axelrod.basic_strategies
-        cls.expected_strategies = (
+        cls.expected_ordinary_strategies = (
             axelrod.ordinary_strategies)
         cls.expected_cheating_strategies = axelrod.cheating_strategies
-        cls.expected_all_strategies = (
+        cls.expected_strategies = (
             axelrod.ordinary_strategies +
             axelrod.cheating_strategies)
 
@@ -37,14 +37,14 @@ def test_tournaments_dict(self):
         actual_strategies = self.tmf._tournaments_dict()['strategies']
         actual_cheating_strategies = (
             self.tmf._tournaments_dict()['cheating_strategies'])
-        actual_all_strategies = self.tmf._tournaments_dict()['all_strategies']
+        actual_all_strategies = self.tmf._tournaments_dict()['strategies']
 
         self.assertEqual(
             actual_basic_strategies, self.expected_basic_strategies)
         self.assertEqual(actual_strategies, self.expected_strategies)
         self.assertEqual(
             actual_cheating_strategies, self.expected_cheating_strategies)
-        self.assertEqual(actual_all_strategies, self.expected_all_strategies)
+        self.assertEqual(actual_all_strategies, self.expected_strategies)
 
         # Tests to ensure that the exclusions list works as intended
         with_exclusions = self.tmf._tournaments_dict(self.test_exclusions)
@@ -61,7 +61,84 @@ def test_add_tournaments(self):
         self.tmf._add_tournaments(mgr, self.test_exclusions, self.test_kwargs)
         self.assertEqual(len(mgr._tournaments), 2)
         self.assertIsInstance(mgr._tournaments[0], axelrod.Tournament)
-        self.assertEqual(mgr._tournaments[0].name, 'strategies')
+        self.assertEqual(mgr._tournaments[0].name, 'ordinary_strategies')
+
+    def test_create_tournament_manager(self):
+        mgr = self.tmf.create_tournament_manager(
+            output_directory=self.test_output_directory,
+            no_ecological=False,
+            rebuild_cache=self.test_rebuild_cache,
+            cache_file=self.test_cache_file,
+            exclusions=self.test_exclusions,
+            **self.test_kwargs)
+
+        self.assertIsInstance(mgr, axelrod.TournamentManager)
+        self.assertEqual(mgr._output_directory, self.test_output_directory)
+        self.assertEqual(len(mgr._tournaments), 2)
+        self.assertTrue(mgr._with_ecological)
+        self.assertTrue(mgr._pass_cache)
+
+
+class TestProbEndTournamentManagerFactory(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.tmf = axelrod.ProbEndTournamentManagerFactory
+
+        cls.test_output_directory = './assets/'
+        cls.test_with_ecological = True
+        cls.test_rebuild_cache = False
+        cls.test_cache_file = './cache.txt'
+        cls.test_exclusions = ['basic_strategies', 'cheating_strategies']
+        cls.test_kwargs = {
+            'processes': 2,
+            'prob_end': .1,
+            'repetitions': 200,
+            'noise': 0
+        }
+
+        cls.expected_basic_strategies = axelrod.basic_strategies
+        cls.expected_ordinary_strategies = (
+            axelrod.ordinary_strategies)
+        cls.expected_cheating_strategies = axelrod.cheating_strategies
+        cls.expected_strategies = (
+            axelrod.ordinary_strategies +
+            axelrod.cheating_strategies)
+
+    def test_tournaments_dict(self):
+
+        # Tests to ensure that the tournaments dictionary contains the correct
+        # keys and values
+        actual_basic_strategies = (
+            self.tmf._tournaments_dict()['basic_strategies_prob_end'])
+        actual_ordinary_strategies = self.tmf._tournaments_dict()['ordinary_strategies_prob_end']
+        actual_cheating_strategies = (
+            self.tmf._tournaments_dict()['cheating_strategies_prob_end'])
+        actual_all_strategies = self.tmf._tournaments_dict()['strategies_prob_end']
+
+        self.assertEqual(
+            actual_basic_strategies, self.expected_basic_strategies)
+        self.assertEqual(actual_ordinary_strategies, self.expected_ordinary_strategies)
+        self.assertEqual(
+            actual_cheating_strategies, self.expected_cheating_strategies)
+        self.assertEqual(actual_all_strategies, self.expected_strategies)
+
+        # Tests to ensure that the exclusions list works as intended
+        with_exclusions = self.tmf._tournaments_dict(self.test_exclusions)
+        self.assertFalse('basic_strategies' in with_exclusions)
+        self.assertFalse('cheating_strategies' in with_exclusions)
+        self.assertEqual(
+            with_exclusions['strategies_prob_end'], self.expected_strategies)
+
+    def test_add_tournaments(self):
+        mgr = axelrod.ProbEndTournamentManager(
+            self.test_output_directory,
+            self.test_with_ecological)
+
+        self.tmf._add_tournaments(mgr, self.test_exclusions, self.test_kwargs)
+        self.assertEqual(len(mgr._tournaments), 2)
+        self.assertIsInstance(mgr._tournaments[0], axelrod.Tournament)
+        self.assertEqual(mgr._tournaments[0].name, 'ordinary_strategies_prob_end')
 
     def test_create_tournament_manager(self):
         mgr = self.tmf.create_tournament_manager(

axelrod/tests/unit/test_utils.py

@@ -2,6 +2,7 @@
 
 import axelrod
 import unittest
+import itertools
 
 from hypothesis import given
 from hypothesis.strategies import floats, text
@@ -26,7 +27,6 @@ def test_time_message_example(self):
         self.assertGreaterEqual(float(timed_message[len(message)+4:-1]), 0)
 
 
-
 class TestSetupLogging(unittest.TestCase):
 
     def test_basic_configuration_console(self):
@@ -41,3 +41,18 @@ def test_basic_configuration_console(self):
             axelrod.utils.setup_logging(logging_destination='console',
                                         verbosity=level)
             compare(logger.level, levels[level])
+
+
+class TestBuildExclusionsDict(unittest.TestCase):
+    def test_build_exclusions_dict(self):
+        """This is really a regression test to make sure the names of the
+        tournaments stay consistent"""
+        bools = [True, False]
+        for (eb, eo, ec, eco) in itertools.product(bools, repeat=4):
+            expected_dict = {
+                'basic_strategies': eb,
+                'ordinary_strategies': eo,
+                'cheating_strategies': ec,
+                'strategies': eco}
+            self.assertEqual(axelrod.utils.build_exclusions_dict(eb, eo, ec, eco),
+                             expected_dict)

axelrod/tournament_manager.py

@@ -10,11 +10,19 @@
 
 
 class TournamentManager(object):
+    """A class to manage and create tournaments."""
 
     plot_types = {'boxplot': "Payoffs. ", 'payoff': "Payoffs. ",
                   'winplot': "Wins. ", 'sdvplot': "Std Payoffs. ",
                   'pdplot': "Payoff differences. ", 'lengthplot': "Lengths. "}
 
+    ecoturns = {
+            'basic_strategies': 1000,
+            'cheating_strategies': 10,
+            'ordinary_strategies': 1000,
+            'strategies': 10,
+        }
+
     def __init__(self, output_directory, with_ecological,
                  pass_cache=True, load_cache=True, save_cache=False,
                  cache_file='./cache.txt', image_format="svg"):
@@ -61,8 +69,8 @@ def run_tournaments(self):
 
     def _run_single_tournament(self, tournament):
         self._logger.info(
-            'Starting %s tournament with %d round robins of %d turns per pair.'
-            % (tournament.name, tournament.repetitions, tournament.turns))
+                'Starting {} tournament: '.format(tournament.name) + self._tournament_label(tournament)
+            )
 
         t0 = time.time()
 
@@ -103,13 +111,7 @@ def run_ecological_variant(self, tournament, ecosystem):
         self._logger.debug(
             'Starting ecological variant of %s' % tournament.name)
         t0 = time.time()
-        ecoturns = {
-            'basic_strategies': 1000,
-            'cheating_strategies': 10,
-            'strategies': 1000,
-            'all_strategies': 10,
-        }
-        ecosystem.reproduce(ecoturns.get(tournament.name))
+        ecosystem.reproduce(self.ecoturns.get(tournament.name))
         self._logger.debug(
             timed_message('Finished ecological variant of %s' % tournament.name, t0))
 
@@ -186,6 +188,36 @@ def _load_cache_from_file(self, file_name):
             return False
 
 
+class ProbEndTournamentManager(TournamentManager):
+    """A class to manage and create probabilistic ending tournaments."""
+
+    ecoturns = {
+            'basic_strategies_prob_end': 1000,
+            'cheating_strategies_prob_end': 10,
+            'ordinary_strategies_prob_end': 1000,
+            'strategies_prob_end': 10,
+        }
+
+    def add_tournament(self, name, players, game=None, prob_end=.01,
+                       repetitions=10, processes=None, noise=0,
+                       with_morality=True):
+        tournament = ProbEndTournament(
+            name=name,
+            players=players,
+            prob_end=prob_end,
+            repetitions=repetitions,
+            processes=processes,
+            noise=noise,
+            with_morality=with_morality)
+        self._tournaments.append(tournament)
+
+    def _tournament_label(self, tournament):
+        """A label for the tournament for the corresponding title plots"""
+        return "Prob end: {}, Repetitions: {}, Strategies: {}.".format(tournament.prob_end,
+                                                       tournament.repetitions,
+                                                       len(tournament.players))
+
+
 class DeterministicCache(object):
 
     def __init__(self, cache, turns):