Remove keep interactions for resultsset from file

Todo: adjust docs.

Author: drvinceknight

axelrod/result_set.py

@@ -753,7 +753,7 @@ class ResultSetFromFile(ResultSet):
 
     def __init__(self, filename, progress_bar=True,
                  num_interactions=False, players=False, nrepetitions=False,
-                 game=None, keep_interactions=False):
+                 game=None):
         """
         Parameters
         ----------
@@ -773,10 +773,6 @@ def __init__(self, filename, progress_bar=True,
                 efficiently read from file.
             game : axelrod.Game
                 The particular game that should be used to calculate the scores.
-            keep_interactions : bool
-                Whether or not to load the interactions in to memory. WARNING:
-                for large tournaments this drastically increases the memory
-                required.
         """
         if game is None:
             self.game = Game()
@@ -792,9 +788,8 @@ def __init__(self, filename, progress_bar=True,
             self.players, self.nrepetitions = players, nrepetitions
         self.nplayers = len(self.players)
 
-        self._build_empty_metrics(keep_interactions=keep_interactions)
-        self._build_score_related_metrics(progress_bar=progress_bar,
-                                          keep_interactions=keep_interactions)
+        self._build_empty_metrics()
+        self._build_score_related_metrics(progress_bar=progress_bar)
 
     def create_progress_bar(self, desc=None):
         """
@@ -943,16 +938,10 @@ def read_match_chunks(self, progress_bar=False):
         if progress_bar:
             progress_bar.close()
 
-    def _build_empty_metrics(self, keep_interactions=False):
+    def _build_empty_metrics(self):
         """
         Creates the various empty metrics ready to be updated as the data is
         read.
-
-        Parameters
-        ----------
-
-            keep_interactions : bool
-                Whether or not to load the interactions in to memory
         """
         plist = range(self.nplayers)
         replist = range(self.nrepetitions)
@@ -973,8 +962,6 @@ def _build_empty_metrics(self, keep_interactions=False):
         self.total_interactions = [0 for player in plist]
         self.good_partner_rating = [0 for player in plist]
 
-        if keep_interactions:
-            self.interactions = {}
 
     def _update_match_lengths(self, repetition, p1, p2, interaction):
         self.match_lengths[repetition][p1][p2] = len(interaction)
@@ -1054,17 +1041,14 @@ def build_good_partner_rating(self):
                 max(1, float(self.total_interactions[player]))
                 for player in range(self.nplayers)]
 
-    def _build_score_related_metrics(self, progress_bar=False,
-                                     keep_interactions=False):
+    def _build_score_related_metrics(self, progress_bar=False):
         """
         Read the data and carry out all relevant calculations.
 
         Parameters
         ----------
             progress_bar : bool
                 Whether or not to display a progress bar
-            keep_interactions : bool
-                Whether or not to lad the interactions in to memory
         """
         match_chunks = self.read_match_chunks(progress_bar)
 
@@ -1074,12 +1058,6 @@ def _build_score_related_metrics(self, progress_bar=False,
             for repetition, record in enumerate(match):
                 interaction = list(zip(record[4], record[5]))
 
-                if keep_interactions:
-                    try:
-                        self.interactions[(p1, p2)].append(interaction)
-                    except KeyError:
-                        self.interactions[(p1, p2)] = [interaction]
-
                 scores_per_turn = iu.compute_final_score_per_turn(interaction,
                                                                  game=self.game)
                 cooperations = iu.compute_cooperations(interaction)

docs/tutorials/advanced/making_tournaments.rst

@@ -41,7 +41,7 @@ Using this class we can create a tournament with little effort::
     >>> players = [axl.Cooperator(), axl.Defector(), axl.TitForTat(),
     ...            axl.Grudger(), axl.Alternator()]
     >>> tournament = axl.Tournament(players, match_generator=StochasticMatchups, turns=2, repetitions=2)
-    >>> results = tournament.play(keep_interactions=True)
+    >>> results = tournament.play()
 
 We can then look at the interactions (results may differ based on random seed)
 for the first repetition::
@@ -88,6 +88,6 @@ We can take a look at the match lengths when using this generator::
     ...            axl.Grudger(), axl.Alternator()]
     >>> tournament = axl.Tournament(players, match_generator=OneShotOrRepetitionMatchups,
     ...                             turns=float("inf"), repetitions=1)
-    >>> results = tournament.play(keep_interactions=True)
+    >>> results = tournament.play()
     >>> sorted(list(set([len(matches[0]) for matches in results.interactions.values()])))
     [1, 200]

docs/tutorials/further_topics/spatial_tournaments.rst

@@ -29,7 +29,7 @@ indices::
 To create a spatial tournament you call the :code:`SpatialTournamnent` class::
 
     >>> spatial_tournament = axl.SpatialTournament(players, edges=edges)
-    >>> results = spatial_tournament.play(keep_interactions=True)
+    >>> results = spatial_tournament.play()
 
 We can plot the results::
 
@@ -50,7 +50,7 @@ Let's run a small tournament of 2 :code:`turns` and 5 :code:`repetitions`
 and obtain the interactions::
 
     >>> spatial_tournament = axl.SpatialTournament(players ,turns=2, repetitions=2, edges=edges)
-    >>> results = spatial_tournament.play(keep_interactions=True)
+    >>> results = spatial_tournament.play()
     >>> for index_pair, interaction in results.interactions.items():
     ...     player1 = spatial_tournament.players[index_pair[0]]
     ...     player2 = spatial_tournament.players[index_pair[1]]
@@ -67,11 +67,10 @@ It is also possible to create a probabilistic ending spatial tournament with the
 :code:`ProbEndSpatialTournament` class::
 
     >>> prob_end_spatial_tournament = axl.ProbEndSpatialTournament(players, edges=edges, prob_end=.1, repetitions=1)
-    >>> prob_end_results = prob_end_spatial_tournament.play(keep_interactions=True)
+    >>> prob_end_results = prob_end_spatial_tournament.play()
 
 We see that the match lengths are no longer all equal::
 
-    >>> axl.seed(0)
     >>> lengths = []
     >>> for interaction in prob_end_results.interactions.values():
     ...     lengths.append(len(interaction[0]))

docs/tutorials/getting_started/interactions.rst

@@ -13,7 +13,7 @@ interactions::
     ...     axl.Cooperator(), axl.Defector(),
     ...     axl.TitForTat(), axl.Grudger()]
     >>> tournament = axl.Tournament(players, turns=3, repetitions=1)
-    >>> results = tournament.play(keep_interactions=True)
+    >>> results = tournament.play()
 
 If the play method is called with :code:`keep_interactions=True`, the result set
 object will have an :code:`interactions` attribute which contains all the
@@ -23,17 +23,17 @@ view the history of the interactions::
     >>> for index_pair, interaction in results.interactions.items():
     ...     player1 = tournament.players[index_pair[0]]
     ...     player2 = tournament.players[index_pair[1]]
-    ...     print('%s vs %s: %s' % (player1, player2, interaction)) # doctest: +SKIP
-    Cooperator vs Defector: [('C', 'D'), ('C', 'D'), ('C', 'D')]
-    Defector vs Tit For Tat: [('D', 'C'), ('D', 'D'), ('D', 'D')]
-    Cooperator vs Cooperator: [('C', 'C'), ('C', 'C'), ('C', 'C')]
-    Tit For Tat vs Grudger: [('C', 'C'), ('C', 'C'), ('C', 'C')]
-    Grudger vs Grudger: [('C', 'C'), ('C', 'C'), ('C', 'C')]
-    Tit For Tat vs Tit For Tat: [('C', 'C'), ('C', 'C'), ('C', 'C')]
-    Defector vs Grudger: [('D', 'C'), ('D', 'D'), ('D', 'D')]
-    Cooperator vs Grudger: [('C', 'C'), ('C', 'C'), ('C', 'C')]
-    Cooperator vs Tit For Tat: [('C', 'C'), ('C', 'C'), ('C', 'C')]
-    Defector vs Defector: [('D', 'D'), ('D', 'D'), ('D', 'D')]
+    ...     print('%s vs %s: %s' % (player1, player2, interaction))
+    Cooperator vs Defector: [[('C', 'D'), ('C', 'D'), ('C', 'D')]]
+    Defector vs Tit For Tat: [[('D', 'C'), ('D', 'D'), ('D', 'D')]]
+    Cooperator vs Cooperator: [[('C', 'C'), ('C', 'C'), ('C', 'C')]]
+    Tit For Tat vs Grudger: [[('C', 'C'), ('C', 'C'), ('C', 'C')]]
+    Grudger vs Grudger: [[('C', 'C'), ('C', 'C'), ('C', 'C')]]
+    Tit For Tat vs Tit For Tat: [[('C', 'C'), ('C', 'C'), ('C', 'C')]]
+    Defector vs Grudger: [[('D', 'C'), ('D', 'D'), ('D', 'D')]]
+    Cooperator vs Grudger: [[('C', 'C'), ('C', 'C'), ('C', 'C')]]
+    Cooperator vs Tit For Tat: [[('C', 'C'), ('C', 'C'), ('C', 'C')]]
+    Defector vs Defector: [[('D', 'D'), ('D', 'D'), ('D', 'D')]]
 
 We can use these interactions to reconstruct :code:`axelrod.Match` objects which
 have a variety of available methods for analysis (more information can be found

docs/tutorials/getting_started/tournament_results.rst

@@ -166,7 +166,7 @@ We see that :code:`Cooperator` has no difference in score with all players
 except against the :code:`Defector`::
 
     >>> results.score_diffs[0]
-    [[-0.0, -0.0, -0.0], [-5.0, -5.0, -5.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
+    [[0.0, 0.0, 0.0], [-5.0, -5.0, -5.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
 
 Payoff difference means
 -----------------------