Make temp file default: switch to mem if win

Author: drvinceknight

axelrod/__init__.py

@@ -1,6 +1,8 @@
 from __future__ import absolute_import
 import sys
 
+on_windows = sys.platform.startswith("win")
+
 # The order of imports matters!
 from .actions import Actions, flip_action
 from .random_ import random_choice, seed
@@ -16,5 +18,3 @@
 from .tournament import Tournament, ProbEndTournament, SpatialTournament, ProbEndSpatialTournament
 from .result_set import ResultSet, ResultSetFromFile
 from .ecosystem import Ecosystem
-
-on_windows = sys.platform.startswith("win")

axelrod/tournament.py

@@ -1,17 +1,17 @@
 from __future__ import absolute_import
 
-import csv
 from collections import defaultdict
-import logging
 from multiprocessing import Process, Queue, cpu_count
-import warnings
-
+from tempfile import NamedTemporaryFile
+import csv
+import logging
 import tqdm
+import warnings
 
+from axelrod import on_windows
 from .game import Game
 from .match import Match
-from .match_generator import (RoundRobinMatches, ProbEndRoundRobinMatches,
-                              SpatialMatches, ProbEndSpatialMatches)
+from .match_generator import RoundRobinMatches, ProbEndRoundRobinMatches, SpatialMatches, ProbEndSpatialMatches
 from .result_set import ResultSetFromFile, ResultSet
 
 
@@ -55,8 +55,25 @@ def __init__(self, players, match_generator=RoundRobinMatches,
         self._with_morality = with_morality
         self._logger = logging.getLogger(__name__)
 
+    def setup_output_file(self, filename=None, in_memory=False):
+        """Open a CSV writer for tournament output."""
+        if in_memory:
+            self.interactions_dict = {}
+            self.writer = None
+        else:
+            if filename:
+                self.outputfile = open(filename, 'w')
+            else:
+                # Setup a temporary file
+                self.outputfile = NamedTemporaryFile(mode='w')
+                filename = self.outputfile.name
+            self.writer = csv.writer(self.outputfile, lineterminator='\n')
+            # Save filename for loading ResultSet later
+            self.filename = filename
+
     def play(self, build_results=True, filename=None,
-             processes=None, progress_bar=True, keep_interactions=False):
+             processes=None, progress_bar=True,
+             keep_interactions=False, in_memory=False):
         """
         Plays the tournament and passes the results to the ResultSet class
 
@@ -71,8 +88,11 @@ def play(self, build_results=True, filename=None,
         progress_bar : bool
             Whether or not to create a progress bar which will be updated
         keep_interactions : bool
-            Whether or not to save the interactions to memory. Only relevant
-            when writing to file.
+            Whether or not to load the interactions in to memory
+        in_memory : bool
+            By default interactions are written to a file.
+            If this is True they will be kept in memory.
+            This is not advised for large tournaments.
 
         Returns
         -------
@@ -82,18 +102,12 @@ def play(self, build_results=True, filename=None,
             self.progress_bar = tqdm.tqdm(total=len(self.match_generator),
                                           desc="Playing matches")
 
-        if filename is not None:
-            self.outputfile = open(filename, 'w')
-            self.writer = csv.writer(self.outputfile, lineterminator='\n')
-            self.filename = filename
-            self.interactions_dict = None
-        else:
-            self.outputfile = None
-            self.writer = None
-            self.filename = None
-            self.interactions_dict = {}
+        if on_windows and (filename is None):
+            in_memory = True
 
-        if (not build_results) and (filename is None):
+        self.setup_output_file(filename, in_memory)
+
+        if not build_results and not filename:
             warnings.warn("Tournament results will not be accessible since build_results=False and no filename was supplied.")
 
         if processes is None:
@@ -104,36 +118,40 @@ def play(self, build_results=True, filename=None,
         if progress_bar:
             self.progress_bar.close()
 
-        if filename:
+        # Make sure that python has finished writing to disk
+        if not in_memory:
             self.outputfile.flush()
-            self.outputfile.close()
 
         if build_results:
             return self._build_result_set(progress_bar=progress_bar,
-                                          keep_interactions=keep_interactions)
+                                          keep_interactions=keep_interactions,
+                                          in_memory=in_memory)
+        else:
+            self.outputfile.close()
 
-    def _build_result_set(self, progress_bar=True, keep_interactions=False):
+    def _build_result_set(self, progress_bar=True, keep_interactions=False,
+                          in_memory=False):
         """
         Build the result set (used by the play method)
 
         Returns
         -------
         axelrod.BigResultSet
         """
-        if self.filename is not None:
+        if not in_memory:
             result_set = ResultSetFromFile(filename=self.filename,
                                            progress_bar=progress_bar,
                                            num_interactions=self.num_interactions,
                                            nrepetitions=self.repetitions,
-                                           keep_interactions=keep_interactions,
                                            players=[str(p) for p in self.players],
+                                           keep_interactions=keep_interactions,
                                            game=self.game)
             self.outputfile.close()
         else:
             result_set = ResultSet(players=[str(p) for p in self.players],
-                                   interactions=self.interactions_dict,
-                                   progress_bar=progress_bar,
-                                   game=self.game)
+                                     interactions=self.interactions_dict,
+                                     progress_bar=progress_bar,
+                                     game=self.game)
         return result_set
 
     def _run_serial(self, progress_bar=False):
@@ -159,13 +177,13 @@ def _run_serial(self, progress_bar=False):
 
     def _write_interactions(self, results):
         """Write the interactions to file or to a dictionary"""
-        if self.interactions_dict is not None:
-            self._write_to_dict(results)
-        elif self.writer is not None:
-            self._write_to_file(results)
+        if self.writer is not None:
+          self._write_interactions_to_file(results)
+        elif self.interactions_dict is not None:
+          self._write_interactions_to_dict(results)
 
-    def _write_to_file(self, results):
-        """Write the interactions to csv file"""
+    def _write_interactions_to_file(self, results):
+        """Write the interactions to csv."""
         for index_pair, interactions in results.items():
             for interaction in interactions:
                 row = list(index_pair)
@@ -178,7 +196,7 @@ def _write_to_file(self, results):
                 self.writer.writerow(row)
                 self.num_interactions += 1
 
-    def _write_to_dict(self, results):
+    def _write_interactions_to_dict(self, results):
         """Write the interactions to memory"""
         for index_pair, interactions in results.items():
             for interaction in interactions: