tempfile.TemporaryDirectory context manager in Python 2.7

Another option is the "backports.tempfile" package on pypi: https://pypi.python.org/pypi/backports.tempfile

Quoting the project's description: "This package provides backports of new features in Python’s tempfile module under the backports namespace."

Install with:

pip install backports.tempfile

Then use it in your script:

from backports import tempfilewith tempfile.TemporaryDirectory() as temp_dir:    # modify files in this dir# here the temporary directory does not exist any more.

tempfile.TemporaryDirectory() was added to the tempfile standard library in Python 3.2

It's a simple wrapper for tempfile.mkdtemp. It is coded in pure Python and can be easily ported to Python 2.7.

For example:

from __future__ import print_functionimport warnings as _warningsimport os as _osfrom tempfile import mkdtempclass TemporaryDirectory(object):    """Create and return a temporary directory.  This has the same    behavior as mkdtemp but can be used as a context manager.  For    example:        with TemporaryDirectory() as tmpdir:            ...    Upon exiting the context, the directory and everything contained    in it are removed.    """    def __init__(self, suffix="", prefix="tmp", dir=None):        self._closed = False        self.name = None # Handle mkdtemp raising an exception        self.name = mkdtemp(suffix, prefix, dir)    def __repr__(self):        return "<{} {!r}>".format(self.__class__.__name__, self.name)    def __enter__(self):        return self.name    def cleanup(self, _warn=False):        if self.name and not self._closed:            try:                self._rmtree(self.name)            except (TypeError, AttributeError) as ex:                # Issue #10188: Emit a warning on stderr                # if the directory could not be cleaned                # up due to missing globals                if "None" not in str(ex):                    raise                print("ERROR: {!r} while cleaning up {!r}".format(ex, self,),                      file=_sys.stderr)                return            self._closed = True            if _warn:                self._warn("Implicitly cleaning up {!r}".format(self),                           ResourceWarning)    def __exit__(self, exc, value, tb):        self.cleanup()    def __del__(self):        # Issue a ResourceWarning if implicit cleanup needed        self.cleanup(_warn=True)    # XXX (ncoghlan): The following code attempts to make    # this class tolerant of the module nulling out process    # that happens during CPython interpreter shutdown    # Alas, it doesn't actually manage it. See issue #10188    _listdir = staticmethod(_os.listdir)    _path_join = staticmethod(_os.path.join)    _isdir = staticmethod(_os.path.isdir)    _islink = staticmethod(_os.path.islink)    _remove = staticmethod(_os.remove)    _rmdir = staticmethod(_os.rmdir)    _warn = _warnings.warn    def _rmtree(self, path):        # Essentially a stripped down version of shutil.rmtree.  We can't        # use globals because they may be None'ed out at shutdown.        for name in self._listdir(path):            fullname = self._path_join(path, name)            try:                isdir = self._isdir(fullname) and not self._islink(fullname)            except OSError:                isdir = False            if isdir:                self._rmtree(fullname)            else:                try:                    self._remove(fullname)                except OSError:                    pass        try:            self._rmdir(path)        except OSError:            passimport oswith TemporaryDirectory() as tmp_dir:    print("Temporary directory path: %s" % tmp_dir)    print(os.path.isdir(tmp_dir))# here the temporary diretory does not exist any more.print(os.path.isdir(tmp_dir))