Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 1 | """Temporary files. |
Guido van Rossum | e7b146f | 2000-02-04 15:28:42 +0000 | [diff] [blame] | 2 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 3 | This module provides generic, low- and high-level interfaces for |
Yury Selivanov | 0b86660 | 2014-09-26 17:08:21 -0400 | [diff] [blame] | 4 | creating temporary files and directories. All of the interfaces |
| 5 | provided by this module can be used without fear of race conditions |
| 6 | except for 'mktemp'. 'mktemp' is subject to race conditions and |
| 7 | should not be used; it is provided for backward compatibility only. |
Guido van Rossum | eee9498 | 1991-11-12 15:38:08 +0000 | [diff] [blame] | 8 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 9 | The default path names are returned as str. If you supply bytes as |
| 10 | input, all return values will be in bytes. Ex: |
| 11 | |
| 12 | >>> tempfile.mkstemp() |
| 13 | (4, '/tmp/tmptpu9nin8') |
| 14 | >>> tempfile.mkdtemp(suffix=b'') |
| 15 | b'/tmp/tmppbi8f0hy' |
| 16 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 17 | This module also provides some data items to the user: |
Guido van Rossum | eee9498 | 1991-11-12 15:38:08 +0000 | [diff] [blame] | 18 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 19 | TMP_MAX - maximum number of names that will be tried before |
| 20 | giving up. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 21 | tempdir - If this is set to a string before the first use of |
| 22 | any routine from this module, it will be considered as |
| 23 | another candidate location to store temporary files. |
| 24 | """ |
Skip Montanaro | 40fc160 | 2001-03-01 04:27:19 +0000 | [diff] [blame] | 25 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 26 | __all__ = [ |
| 27 | "NamedTemporaryFile", "TemporaryFile", # high level safe interfaces |
Nick Coghlan | 543af75 | 2010-10-24 11:23:25 +0000 | [diff] [blame] | 28 | "SpooledTemporaryFile", "TemporaryDirectory", |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 29 | "mkstemp", "mkdtemp", # low level safe interfaces |
| 30 | "mktemp", # deprecated unsafe interface |
| 31 | "TMP_MAX", "gettempprefix", # constants |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 32 | "tempdir", "gettempdir", |
| 33 | "gettempprefixb", "gettempdirb", |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 34 | ] |
Guido van Rossum | 41f9503 | 1992-03-31 19:02:01 +0000 | [diff] [blame] | 35 | |
Tim Peters | 4fd5a06 | 2002-01-28 23:11:23 +0000 | [diff] [blame] | 36 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 37 | # Imports. |
Tim Peters | 4fd5a06 | 2002-01-28 23:11:23 +0000 | [diff] [blame] | 38 | |
Antoine Pitrou | 17c9326 | 2013-12-21 22:14:56 +0100 | [diff] [blame] | 39 | import functools as _functools |
Nick Coghlan | 6b22f3f | 2010-12-12 15:24:21 +0000 | [diff] [blame] | 40 | import warnings as _warnings |
Guido van Rossum | 9a63470 | 2007-07-09 10:24:45 +0000 | [diff] [blame] | 41 | import io as _io |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 42 | import os as _os |
Serhiy Storchaka | 99e033b | 2014-01-27 11:18:27 +0200 | [diff] [blame] | 43 | import shutil as _shutil |
Serhiy Storchaka | 7451a72 | 2013-02-09 22:25:49 +0200 | [diff] [blame] | 44 | import errno as _errno |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 45 | from random import Random as _Random |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 46 | import weakref as _weakref |
Antoine Pitrou | a6a4dc8 | 2017-09-07 18:56:24 +0200 | [diff] [blame] | 47 | import _thread |
Guido van Rossum | a093424 | 2002-12-30 22:36:09 +0000 | [diff] [blame] | 48 | _allocate_lock = _thread.allocate_lock |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 49 | |
| 50 | _text_openflags = _os.O_RDWR | _os.O_CREAT | _os.O_EXCL |
Tim Peters | a0d55de | 2002-08-09 18:01:01 +0000 | [diff] [blame] | 51 | if hasattr(_os, 'O_NOFOLLOW'): |
| 52 | _text_openflags |= _os.O_NOFOLLOW |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 53 | |
| 54 | _bin_openflags = _text_openflags |
Tim Peters | a0d55de | 2002-08-09 18:01:01 +0000 | [diff] [blame] | 55 | if hasattr(_os, 'O_BINARY'): |
| 56 | _bin_openflags |= _os.O_BINARY |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 57 | |
| 58 | if hasattr(_os, 'TMP_MAX'): |
| 59 | TMP_MAX = _os.TMP_MAX |
| 60 | else: |
| 61 | TMP_MAX = 10000 |
| 62 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 63 | # This variable _was_ unused for legacy reasons, see issue 10354. |
| 64 | # But as of 3.5 we actually use it at runtime so changing it would |
| 65 | # have a possibly desirable side effect... But we do not want to support |
| 66 | # that as an API. It is undocumented on purpose. Do not depend on this. |
Tim Peters | bd7b4c7 | 2002-08-13 23:33:56 +0000 | [diff] [blame] | 67 | template = "tmp" |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 68 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 69 | # Internal routines. |
| 70 | |
| 71 | _once_lock = _allocate_lock() |
| 72 | |
Guido van Rossum | b25615939 | 2003-11-10 02:16:36 +0000 | [diff] [blame] | 73 | if hasattr(_os, "lstat"): |
| 74 | _stat = _os.lstat |
| 75 | elif hasattr(_os, "stat"): |
| 76 | _stat = _os.stat |
| 77 | else: |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 78 | # Fallback. All we need is something that raises OSError if the |
Guido van Rossum | b25615939 | 2003-11-10 02:16:36 +0000 | [diff] [blame] | 79 | # file doesn't exist. |
| 80 | def _stat(fn): |
Victor Stinner | daf4555 | 2013-08-28 00:53:59 +0200 | [diff] [blame] | 81 | fd = _os.open(fn, _os.O_RDONLY) |
Victor Stinner | 69b1e26 | 2014-03-20 08:50:52 +0100 | [diff] [blame] | 82 | _os.close(fd) |
Guido van Rossum | b25615939 | 2003-11-10 02:16:36 +0000 | [diff] [blame] | 83 | |
| 84 | def _exists(fn): |
| 85 | try: |
| 86 | _stat(fn) |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 87 | except OSError: |
Guido van Rossum | b25615939 | 2003-11-10 02:16:36 +0000 | [diff] [blame] | 88 | return False |
| 89 | else: |
| 90 | return True |
| 91 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 92 | |
| 93 | def _infer_return_type(*args): |
| 94 | """Look at the type of all args and divine their implied return type.""" |
| 95 | return_type = None |
| 96 | for arg in args: |
| 97 | if arg is None: |
| 98 | continue |
| 99 | if isinstance(arg, bytes): |
| 100 | if return_type is str: |
| 101 | raise TypeError("Can't mix bytes and non-bytes in " |
| 102 | "path components.") |
| 103 | return_type = bytes |
| 104 | else: |
| 105 | if return_type is bytes: |
| 106 | raise TypeError("Can't mix bytes and non-bytes in " |
| 107 | "path components.") |
| 108 | return_type = str |
| 109 | if return_type is None: |
| 110 | return str # tempfile APIs return a str by default. |
| 111 | return return_type |
| 112 | |
| 113 | |
| 114 | def _sanitize_params(prefix, suffix, dir): |
| 115 | """Common parameter processing for most APIs in this module.""" |
| 116 | output_type = _infer_return_type(prefix, suffix, dir) |
| 117 | if suffix is None: |
| 118 | suffix = output_type() |
| 119 | if prefix is None: |
| 120 | if output_type is str: |
| 121 | prefix = template |
| 122 | else: |
| 123 | prefix = _os.fsencode(template) |
| 124 | if dir is None: |
| 125 | if output_type is str: |
| 126 | dir = gettempdir() |
| 127 | else: |
| 128 | dir = gettempdirb() |
| 129 | return prefix, suffix, dir, output_type |
| 130 | |
| 131 | |
Victor Stinner | 1e62bf1 | 2017-04-19 22:59:51 +0200 | [diff] [blame] | 132 | class _RandomNameSequence: |
| 133 | """An instance of _RandomNameSequence generates an endless |
| 134 | sequence of unpredictable strings which can safely be incorporated |
| 135 | into file names. Each string is six characters long. Multiple |
| 136 | threads can safely use the same instance at the same time. |
| 137 | |
| 138 | _RandomNameSequence is an iterator.""" |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 139 | |
Raymond Hettinger | 572895b | 2010-11-09 03:43:58 +0000 | [diff] [blame] | 140 | characters = "abcdefghijklmnopqrstuvwxyz0123456789_" |
Victor Stinner | 1e62bf1 | 2017-04-19 22:59:51 +0200 | [diff] [blame] | 141 | |
| 142 | @property |
| 143 | def rng(self): |
Antoine Pitrou | 4558bad | 2011-11-25 21:28:15 +0100 | [diff] [blame] | 144 | cur_pid = _os.getpid() |
Victor Stinner | 1e62bf1 | 2017-04-19 22:59:51 +0200 | [diff] [blame] | 145 | if cur_pid != getattr(self, '_rng_pid', None): |
| 146 | self._rng = _Random() |
| 147 | self._rng_pid = cur_pid |
| 148 | return self._rng |
| 149 | |
| 150 | def __iter__(self): |
| 151 | return self |
| 152 | |
| 153 | def __next__(self): |
| 154 | c = self.characters |
| 155 | choose = self.rng.choice |
| 156 | letters = [choose(c) for dummy in range(8)] |
| 157 | return ''.join(letters) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 158 | |
| 159 | def _candidate_tempdir_list(): |
| 160 | """Generate a list of candidate temporary directories which |
| 161 | _get_default_tempdir will try.""" |
| 162 | |
| 163 | dirlist = [] |
| 164 | |
| 165 | # First, try the environment. |
| 166 | for envname in 'TMPDIR', 'TEMP', 'TMP': |
| 167 | dirname = _os.getenv(envname) |
| 168 | if dirname: dirlist.append(dirname) |
| 169 | |
| 170 | # Failing that, try OS-specific locations. |
Alexandre Vassalotti | eca20b6 | 2008-05-16 02:54:33 +0000 | [diff] [blame] | 171 | if _os.name == 'nt': |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 172 | dirlist.extend([ r'c:\temp', r'c:\tmp', r'\temp', r'\tmp' ]) |
| 173 | else: |
| 174 | dirlist.extend([ '/tmp', '/var/tmp', '/usr/tmp' ]) |
| 175 | |
| 176 | # As a last resort, the current directory. |
| 177 | try: |
| 178 | dirlist.append(_os.getcwd()) |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 179 | except (AttributeError, OSError): |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 180 | dirlist.append(_os.curdir) |
| 181 | |
| 182 | return dirlist |
Tim Peters | a0d55de | 2002-08-09 18:01:01 +0000 | [diff] [blame] | 183 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 184 | def _get_default_tempdir(): |
| 185 | """Calculate the default directory to use for temporary files. |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 186 | This routine should be called exactly once. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 187 | |
| 188 | We determine whether or not a candidate temp dir is usable by |
| 189 | trying to create and write to a file in that directory. If this |
| 190 | is successful, the test file is deleted. To prevent denial of |
| 191 | service, the name of the test file must be randomized.""" |
| 192 | |
| 193 | namer = _RandomNameSequence() |
| 194 | dirlist = _candidate_tempdir_list() |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 195 | |
| 196 | for dir in dirlist: |
| 197 | if dir != _os.curdir: |
Tim Golden | 6d09f09 | 2013-10-25 18:38:16 +0100 | [diff] [blame] | 198 | dir = _os.path.abspath(dir) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 199 | # Try only a few names per directory. |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 200 | for seq in range(100): |
Georg Brandl | a18af4e | 2007-04-21 15:47:16 +0000 | [diff] [blame] | 201 | name = next(namer) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 202 | filename = _os.path.join(dir, name) |
| 203 | try: |
Amaury Forgeot d'Arc | 7d0bddd | 2009-11-30 00:08:56 +0000 | [diff] [blame] | 204 | fd = _os.open(filename, _bin_openflags, 0o600) |
Serhiy Storchaka | f6b361e | 2013-02-13 00:35:30 +0200 | [diff] [blame] | 205 | try: |
| 206 | try: |
Serhiy Storchaka | 76a2ed1 | 2013-02-13 00:59:26 +0200 | [diff] [blame] | 207 | with _io.open(fd, 'wb', closefd=False) as fp: |
| 208 | fp.write(b'blat') |
Serhiy Storchaka | f6b361e | 2013-02-13 00:35:30 +0200 | [diff] [blame] | 209 | finally: |
| 210 | _os.close(fd) |
| 211 | finally: |
| 212 | _os.unlink(filename) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 213 | return dir |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 214 | except FileExistsError: |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 215 | pass |
Serhiy Storchaka | 5d6b7b1 | 2015-05-20 00:11:48 +0300 | [diff] [blame] | 216 | except PermissionError: |
| 217 | # This exception is thrown when a directory with the chosen name |
| 218 | # already exists on windows. |
| 219 | if (_os.name == 'nt' and _os.path.isdir(dir) and |
| 220 | _os.access(dir, _os.W_OK)): |
| 221 | continue |
| 222 | break # no point trying more names in this directory |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 223 | except OSError: |
| 224 | break # no point trying more names in this directory |
Serhiy Storchaka | 7451a72 | 2013-02-09 22:25:49 +0200 | [diff] [blame] | 225 | raise FileNotFoundError(_errno.ENOENT, |
| 226 | "No usable temporary directory found in %s" % |
| 227 | dirlist) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 228 | |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 229 | _name_sequence = None |
| 230 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 231 | def _get_candidate_names(): |
| 232 | """Common setup sequence for all user-callable interfaces.""" |
| 233 | |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 234 | global _name_sequence |
| 235 | if _name_sequence is None: |
| 236 | _once_lock.acquire() |
| 237 | try: |
| 238 | if _name_sequence is None: |
| 239 | _name_sequence = _RandomNameSequence() |
| 240 | finally: |
| 241 | _once_lock.release() |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 242 | return _name_sequence |
Guido van Rossum | 41f9503 | 1992-03-31 19:02:01 +0000 | [diff] [blame] | 243 | |
| 244 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 245 | def _mkstemp_inner(dir, pre, suf, flags, output_type): |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 246 | """Code common to mkstemp, TemporaryFile, and NamedTemporaryFile.""" |
Tim Peters | 9fadfb0 | 2001-01-13 03:04:02 +0000 | [diff] [blame] | 247 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 248 | names = _get_candidate_names() |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 249 | if output_type is bytes: |
| 250 | names = map(_os.fsencode, names) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 251 | |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 252 | for seq in range(TMP_MAX): |
Georg Brandl | a18af4e | 2007-04-21 15:47:16 +0000 | [diff] [blame] | 253 | name = next(names) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 254 | file = _os.path.join(dir, pre + name + suf) |
| 255 | try: |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 256 | fd = _os.open(file, flags, 0o600) |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 257 | except FileExistsError: |
| 258 | continue # try again |
Eli Bendersky | f315df3 | 2013-09-06 06:11:19 -0700 | [diff] [blame] | 259 | except PermissionError: |
| 260 | # This exception is thrown when a directory with the chosen name |
| 261 | # already exists on windows. |
Serhiy Storchaka | 5d6b7b1 | 2015-05-20 00:11:48 +0300 | [diff] [blame] | 262 | if (_os.name == 'nt' and _os.path.isdir(dir) and |
| 263 | _os.access(dir, _os.W_OK)): |
Eli Bendersky | f315df3 | 2013-09-06 06:11:19 -0700 | [diff] [blame] | 264 | continue |
| 265 | else: |
| 266 | raise |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 267 | return (fd, _os.path.abspath(file)) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 268 | |
Serhiy Storchaka | 7451a72 | 2013-02-09 22:25:49 +0200 | [diff] [blame] | 269 | raise FileExistsError(_errno.EEXIST, |
| 270 | "No usable temporary file name found") |
Tim Peters | a0d55de | 2002-08-09 18:01:01 +0000 | [diff] [blame] | 271 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 272 | |
| 273 | # User visible interfaces. |
Guido van Rossum | b0e5718 | 1998-10-14 20:27:05 +0000 | [diff] [blame] | 274 | |
Guido van Rossum | 41f9503 | 1992-03-31 19:02:01 +0000 | [diff] [blame] | 275 | def gettempprefix(): |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 276 | """The default prefix for temporary directories.""" |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 277 | return template |
Tim Peters | 9fadfb0 | 2001-01-13 03:04:02 +0000 | [diff] [blame] | 278 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 279 | def gettempprefixb(): |
| 280 | """The default prefix for temporary directories as bytes.""" |
| 281 | return _os.fsencode(gettempprefix()) |
| 282 | |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 283 | tempdir = None |
| 284 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 285 | def gettempdir(): |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 286 | """Accessor for tempfile.tempdir.""" |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 287 | global tempdir |
| 288 | if tempdir is None: |
| 289 | _once_lock.acquire() |
| 290 | try: |
| 291 | if tempdir is None: |
| 292 | tempdir = _get_default_tempdir() |
| 293 | finally: |
| 294 | _once_lock.release() |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 295 | return tempdir |
| 296 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 297 | def gettempdirb(): |
| 298 | """A bytes version of tempfile.gettempdir().""" |
| 299 | return _os.fsencode(gettempdir()) |
| 300 | |
| 301 | def mkstemp(suffix=None, prefix=None, dir=None, text=False): |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 302 | """User-callable function to create and return a unique temporary |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 303 | file. The return value is a pair (fd, name) where fd is the |
| 304 | file descriptor returned by os.open, and name is the filename. |
| 305 | |
Martin Panter | 9b566c3 | 2015-11-07 00:32:50 +0000 | [diff] [blame] | 306 | If 'suffix' is not None, the file name will end with that suffix, |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 307 | otherwise there will be no suffix. |
| 308 | |
Martin Panter | 9b566c3 | 2015-11-07 00:32:50 +0000 | [diff] [blame] | 309 | If 'prefix' is not None, the file name will begin with that prefix, |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 310 | otherwise a default prefix is used. |
| 311 | |
Martin Panter | 9b566c3 | 2015-11-07 00:32:50 +0000 | [diff] [blame] | 312 | If 'dir' is not None, the file will be created in that directory, |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 313 | otherwise a default directory is used. |
| 314 | |
Tim Peters | 04490bf | 2002-08-14 15:41:26 +0000 | [diff] [blame] | 315 | If 'text' is specified and true, the file is opened in text |
| 316 | mode. Else (the default) the file is opened in binary mode. On |
| 317 | some operating systems, this makes no difference. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 318 | |
Martin Panter | 9b566c3 | 2015-11-07 00:32:50 +0000 | [diff] [blame] | 319 | If any of 'suffix', 'prefix' and 'dir' are not None, they must be the |
| 320 | same type. If they are bytes, the returned name will be bytes; str |
| 321 | otherwise. |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 322 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 323 | The file is readable and writable only by the creating user ID. |
| 324 | If the operating system uses permission bits to indicate whether a |
| 325 | file is executable, the file is executable by no one. The file |
| 326 | descriptor is not inherited by children of this process. |
| 327 | |
| 328 | Caller is responsible for deleting the file when done with it. |
Tim Peters | 9fadfb0 | 2001-01-13 03:04:02 +0000 | [diff] [blame] | 329 | """ |
| 330 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 331 | prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 332 | |
Tim Peters | 04490bf | 2002-08-14 15:41:26 +0000 | [diff] [blame] | 333 | if text: |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 334 | flags = _text_openflags |
Tim Peters | 04490bf | 2002-08-14 15:41:26 +0000 | [diff] [blame] | 335 | else: |
| 336 | flags = _bin_openflags |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 337 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 338 | return _mkstemp_inner(dir, prefix, suffix, flags, output_type) |
Guido van Rossum | cff3454 | 1992-01-14 18:31:56 +0000 | [diff] [blame] | 339 | |
Guido van Rossum | eee9498 | 1991-11-12 15:38:08 +0000 | [diff] [blame] | 340 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 341 | def mkdtemp(suffix=None, prefix=None, dir=None): |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 342 | """User-callable function to create and return a unique temporary |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 343 | directory. The return value is the pathname of the directory. |
| 344 | |
Tim Peters | 04490bf | 2002-08-14 15:41:26 +0000 | [diff] [blame] | 345 | Arguments are as for mkstemp, except that the 'text' argument is |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 346 | not accepted. |
| 347 | |
| 348 | The directory is readable, writable, and searchable only by the |
| 349 | creating user. |
| 350 | |
| 351 | Caller is responsible for deleting the directory when done with it. |
| 352 | """ |
| 353 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 354 | prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 355 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 356 | names = _get_candidate_names() |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 357 | if output_type is bytes: |
| 358 | names = map(_os.fsencode, names) |
Tim Peters | a0d55de | 2002-08-09 18:01:01 +0000 | [diff] [blame] | 359 | |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 360 | for seq in range(TMP_MAX): |
Georg Brandl | a18af4e | 2007-04-21 15:47:16 +0000 | [diff] [blame] | 361 | name = next(names) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 362 | file = _os.path.join(dir, prefix + name + suffix) |
| 363 | try: |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 364 | _os.mkdir(file, 0o700) |
Florent Xicluna | 68f71a3 | 2011-10-28 16:06:23 +0200 | [diff] [blame] | 365 | except FileExistsError: |
| 366 | continue # try again |
Serhiy Storchaka | 5d6b7b1 | 2015-05-20 00:11:48 +0300 | [diff] [blame] | 367 | except PermissionError: |
| 368 | # This exception is thrown when a directory with the chosen name |
| 369 | # already exists on windows. |
| 370 | if (_os.name == 'nt' and _os.path.isdir(dir) and |
| 371 | _os.access(dir, _os.W_OK)): |
| 372 | continue |
| 373 | else: |
| 374 | raise |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 375 | return file |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 376 | |
Serhiy Storchaka | 7451a72 | 2013-02-09 22:25:49 +0200 | [diff] [blame] | 377 | raise FileExistsError(_errno.EEXIST, |
| 378 | "No usable temporary directory name found") |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 379 | |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 380 | def mktemp(suffix="", prefix=template, dir=None): |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 381 | """User-callable function to return a unique temporary file name. The |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 382 | file is not created. |
| 383 | |
Martin Panter | 9b566c3 | 2015-11-07 00:32:50 +0000 | [diff] [blame] | 384 | Arguments are similar to mkstemp, except that the 'text' argument is |
| 385 | not accepted, and suffix=None, prefix=None and bytes file names are not |
| 386 | supported. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 387 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 388 | THIS FUNCTION IS UNSAFE AND SHOULD NOT BE USED. The file name may |
| 389 | refer to a file that did not exist at some point, but by the time |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 390 | you get around to creating it, someone else may have beaten you to |
| 391 | the punch. |
| 392 | """ |
| 393 | |
Guido van Rossum | 44f602d | 2002-11-22 15:56:29 +0000 | [diff] [blame] | 394 | ## from warnings import warn as _warn |
| 395 | ## _warn("mktemp is a potential security risk to your program", |
| 396 | ## RuntimeWarning, stacklevel=2) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 397 | |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 398 | if dir is None: |
| 399 | dir = gettempdir() |
| 400 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 401 | names = _get_candidate_names() |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 402 | for seq in range(TMP_MAX): |
Georg Brandl | a18af4e | 2007-04-21 15:47:16 +0000 | [diff] [blame] | 403 | name = next(names) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 404 | file = _os.path.join(dir, prefix + name + suffix) |
Guido van Rossum | b25615939 | 2003-11-10 02:16:36 +0000 | [diff] [blame] | 405 | if not _exists(file): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 406 | return file |
Guido van Rossum | ca54982 | 1997-08-12 18:00:12 +0000 | [diff] [blame] | 407 | |
Serhiy Storchaka | 7451a72 | 2013-02-09 22:25:49 +0200 | [diff] [blame] | 408 | raise FileExistsError(_errno.EEXIST, |
| 409 | "No usable temporary filename found") |
Guido van Rossum | ca54982 | 1997-08-12 18:00:12 +0000 | [diff] [blame] | 410 | |
Christian Heimes | 3ecfea71 | 2008-02-09 20:51:34 +0000 | [diff] [blame] | 411 | |
Antoine Pitrou | 17c9326 | 2013-12-21 22:14:56 +0100 | [diff] [blame] | 412 | class _TemporaryFileCloser: |
| 413 | """A separate object allowing proper closing of a temporary file's |
| 414 | underlying file object, without adding a __del__ method to the |
| 415 | temporary file.""" |
Tim Peters | a255a72 | 2001-12-18 22:32:40 +0000 | [diff] [blame] | 416 | |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 417 | file = None # Set here since __del__ checks it |
Serhiy Storchaka | 99e033b | 2014-01-27 11:18:27 +0200 | [diff] [blame] | 418 | close_called = False |
| 419 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 420 | def __init__(self, file, name, delete=True): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 421 | self.file = file |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 422 | self.name = name |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 423 | self.delete = delete |
Guido van Rossum | ca54982 | 1997-08-12 18:00:12 +0000 | [diff] [blame] | 424 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 425 | # NT provides delete-on-close as a primitive, so we don't need |
| 426 | # the wrapper to do anything special. We still use it so that |
| 427 | # file.name is useful (i.e. not "(fdopen)") with NamedTemporaryFile. |
| 428 | if _os.name != 'nt': |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 429 | # Cache the unlinker so we don't get spurious errors at |
| 430 | # shutdown when the module-level "os" is None'd out. Note |
| 431 | # that this must be referenced as self.unlink, because the |
| 432 | # name TemporaryFileWrapper may also get None'd out before |
| 433 | # __del__ is called. |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 434 | |
Serhiy Storchaka | 99e033b | 2014-01-27 11:18:27 +0200 | [diff] [blame] | 435 | def close(self, unlink=_os.unlink): |
| 436 | if not self.close_called and self.file is not None: |
Tim Peters | 6ef966e | 2002-11-21 15:48:33 +0000 | [diff] [blame] | 437 | self.close_called = True |
Serhiy Storchaka | 7e7a3db | 2015-04-10 13:24:41 +0300 | [diff] [blame] | 438 | try: |
| 439 | self.file.close() |
| 440 | finally: |
| 441 | if self.delete: |
| 442 | unlink(self.name) |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 443 | |
Antoine Pitrou | 17c9326 | 2013-12-21 22:14:56 +0100 | [diff] [blame] | 444 | # Need to ensure the file is deleted on __del__ |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 445 | def __del__(self): |
| 446 | self.close() |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 447 | |
Benjamin Peterson | 98d23f2 | 2009-06-30 22:27:25 +0000 | [diff] [blame] | 448 | else: |
Antoine Pitrou | 17c9326 | 2013-12-21 22:14:56 +0100 | [diff] [blame] | 449 | def close(self): |
| 450 | if not self.close_called: |
| 451 | self.close_called = True |
| 452 | self.file.close() |
| 453 | |
| 454 | |
| 455 | class _TemporaryFileWrapper: |
| 456 | """Temporary file wrapper |
| 457 | |
| 458 | This class provides a wrapper around files opened for |
| 459 | temporary use. In particular, it seeks to automatically |
| 460 | remove the file when it is no longer needed. |
| 461 | """ |
| 462 | |
| 463 | def __init__(self, file, name, delete=True): |
| 464 | self.file = file |
| 465 | self.name = name |
| 466 | self.delete = delete |
| 467 | self._closer = _TemporaryFileCloser(file, name, delete) |
| 468 | |
| 469 | def __getattr__(self, name): |
| 470 | # Attribute lookups are delegated to the underlying file |
| 471 | # and cached for non-numeric results |
| 472 | # (i.e. methods are cached, closed and friends are not) |
| 473 | file = self.__dict__['file'] |
| 474 | a = getattr(file, name) |
| 475 | if hasattr(a, '__call__'): |
| 476 | func = a |
| 477 | @_functools.wraps(func) |
| 478 | def func_wrapper(*args, **kwargs): |
| 479 | return func(*args, **kwargs) |
| 480 | # Avoid closing the file as long as the wrapper is alive, |
| 481 | # see issue #18879. |
| 482 | func_wrapper._closer = self._closer |
| 483 | a = func_wrapper |
| 484 | if not isinstance(a, int): |
| 485 | setattr(self, name, a) |
| 486 | return a |
| 487 | |
| 488 | # The underlying __enter__ method returns the wrong object |
| 489 | # (self.file) so override it to return the wrapper |
| 490 | def __enter__(self): |
| 491 | self.file.__enter__() |
| 492 | return self |
| 493 | |
| 494 | # Need to trap __exit__ as well to ensure the file gets |
| 495 | # deleted when used in a with statement |
| 496 | def __exit__(self, exc, value, tb): |
| 497 | result = self.file.__exit__(exc, value, tb) |
| 498 | self.close() |
| 499 | return result |
| 500 | |
| 501 | def close(self): |
| 502 | """ |
| 503 | Close the temporary file, possibly deleting it. |
| 504 | """ |
| 505 | self._closer.close() |
| 506 | |
| 507 | # iter() doesn't use __getattr__ to find the __iter__ method |
| 508 | def __iter__(self): |
Serhiy Storchaka | d83b7c2 | 2015-03-20 16:11:20 +0200 | [diff] [blame] | 509 | # Don't return iter(self.file), but yield from it to avoid closing |
R David Murray | 75ed90a | 2015-03-22 12:33:46 -0400 | [diff] [blame] | 510 | # file as long as it's being used as iterator (see issue #23700). We |
| 511 | # can't use 'yield from' here because iter(file) returns the file |
| 512 | # object itself, which has a close method, and thus the file would get |
| 513 | # closed when the generator is finalized, due to PEP380 semantics. |
Serhiy Storchaka | d83b7c2 | 2015-03-20 16:11:20 +0200 | [diff] [blame] | 514 | for line in self.file: |
| 515 | yield line |
Christian Heimes | 3ecfea71 | 2008-02-09 20:51:34 +0000 | [diff] [blame] | 516 | |
| 517 | |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 518 | def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 519 | newline=None, suffix=None, prefix=None, |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 520 | dir=None, delete=True): |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 521 | """Create and return a temporary file. |
| 522 | Arguments: |
| 523 | 'prefix', 'suffix', 'dir' -- as for mkstemp. |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 524 | 'mode' -- the mode argument to io.open (default "w+b"). |
| 525 | 'buffering' -- the buffer size argument to io.open (default -1). |
| 526 | 'encoding' -- the encoding argument to io.open (default None) |
| 527 | 'newline' -- the newline argument to io.open (default None) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 528 | 'delete' -- whether the file is deleted on close (default True). |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 529 | The file is created as mkstemp() would do it. |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 530 | |
Raymond Hettinger | faa10eb | 2005-01-11 15:33:03 +0000 | [diff] [blame] | 531 | Returns an object with a file-like interface; the name of the file |
Martin Panter | 1f0e1f3 | 2016-02-22 10:10:00 +0000 | [diff] [blame] | 532 | is accessible as its 'name' attribute. The file will be automatically |
| 533 | deleted when it is closed unless the 'delete' argument is set to False. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 534 | """ |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 535 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 536 | prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 537 | |
Amaury Forgeot d'Arc | 7d0bddd | 2009-11-30 00:08:56 +0000 | [diff] [blame] | 538 | flags = _bin_openflags |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 539 | |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 540 | # Setting O_TEMPORARY in the flags causes the OS to delete |
| 541 | # the file when it is closed. This is only supported by Windows. |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 542 | if _os.name == 'nt' and delete: |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 543 | flags |= _os.O_TEMPORARY |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 544 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 545 | (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type) |
Victor Stinner | 1f99f9d | 2014-03-25 09:18:04 +0100 | [diff] [blame] | 546 | try: |
| 547 | file = _io.open(fd, mode, buffering=buffering, |
| 548 | newline=newline, encoding=encoding) |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 549 | |
Victor Stinner | 1f99f9d | 2014-03-25 09:18:04 +0100 | [diff] [blame] | 550 | return _TemporaryFileWrapper(file, name, delete) |
Martin Panter | 7869a22 | 2016-02-28 05:22:20 +0000 | [diff] [blame] | 551 | except BaseException: |
| 552 | _os.unlink(name) |
Victor Stinner | 1f99f9d | 2014-03-25 09:18:04 +0100 | [diff] [blame] | 553 | _os.close(fd) |
| 554 | raise |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 555 | |
Jason Tishler | 80c02af | 2002-08-14 15:10:09 +0000 | [diff] [blame] | 556 | if _os.name != 'posix' or _os.sys.platform == 'cygwin': |
| 557 | # On non-POSIX and Cygwin systems, assume that we cannot unlink a file |
| 558 | # while it is open. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 559 | TemporaryFile = NamedTemporaryFile |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 560 | |
| 561 | else: |
Victor Stinner | d967fc9 | 2014-06-05 14:27:45 +0200 | [diff] [blame] | 562 | # Is the O_TMPFILE flag available and does it work? |
| 563 | # The flag is set to False if os.open(dir, os.O_TMPFILE) raises an |
| 564 | # IsADirectoryError exception |
| 565 | _O_TMPFILE_WORKS = hasattr(_os, 'O_TMPFILE') |
| 566 | |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 567 | def TemporaryFile(mode='w+b', buffering=-1, encoding=None, |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 568 | newline=None, suffix=None, prefix=None, |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 569 | dir=None): |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 570 | """Create and return a temporary file. |
| 571 | Arguments: |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 572 | 'prefix', 'suffix', 'dir' -- as for mkstemp. |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 573 | 'mode' -- the mode argument to io.open (default "w+b"). |
| 574 | 'buffering' -- the buffer size argument to io.open (default -1). |
| 575 | 'encoding' -- the encoding argument to io.open (default None) |
| 576 | 'newline' -- the newline argument to io.open (default None) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 577 | The file is created as mkstemp() would do it. |
Tim Peters | 1baa22a | 2001-01-12 10:02:46 +0000 | [diff] [blame] | 578 | |
Raymond Hettinger | faa10eb | 2005-01-11 15:33:03 +0000 | [diff] [blame] | 579 | Returns an object with a file-like interface. The file has no |
| 580 | name, and will cease to exist when it is closed. |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 581 | """ |
Victor Stinner | d967fc9 | 2014-06-05 14:27:45 +0200 | [diff] [blame] | 582 | global _O_TMPFILE_WORKS |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 583 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 584 | prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) |
Guido van Rossum | e888cdc | 2002-08-17 14:50:24 +0000 | [diff] [blame] | 585 | |
Amaury Forgeot d'Arc | 7d0bddd | 2009-11-30 00:08:56 +0000 | [diff] [blame] | 586 | flags = _bin_openflags |
Victor Stinner | d967fc9 | 2014-06-05 14:27:45 +0200 | [diff] [blame] | 587 | if _O_TMPFILE_WORKS: |
| 588 | try: |
| 589 | flags2 = (flags | _os.O_TMPFILE) & ~_os.O_CREAT |
| 590 | fd = _os.open(dir, flags2, 0o600) |
| 591 | except IsADirectoryError: |
Victor Stinner | 9aba8c8 | 2015-10-21 00:15:08 +0200 | [diff] [blame] | 592 | # Linux kernel older than 3.11 ignores the O_TMPFILE flag: |
| 593 | # O_TMPFILE is read as O_DIRECTORY. Trying to open a directory |
| 594 | # with O_RDWR|O_DIRECTORY fails with IsADirectoryError, a |
| 595 | # directory cannot be open to write. Set flag to False to not |
| 596 | # try again. |
Victor Stinner | d967fc9 | 2014-06-05 14:27:45 +0200 | [diff] [blame] | 597 | _O_TMPFILE_WORKS = False |
| 598 | except OSError: |
| 599 | # The filesystem of the directory does not support O_TMPFILE. |
| 600 | # For example, OSError(95, 'Operation not supported'). |
Victor Stinner | 9aba8c8 | 2015-10-21 00:15:08 +0200 | [diff] [blame] | 601 | # |
| 602 | # On Linux kernel older than 3.11, trying to open a regular |
| 603 | # file (or a symbolic link to a regular file) with O_TMPFILE |
| 604 | # fails with NotADirectoryError, because O_TMPFILE is read as |
| 605 | # O_DIRECTORY. |
Victor Stinner | d967fc9 | 2014-06-05 14:27:45 +0200 | [diff] [blame] | 606 | pass |
| 607 | else: |
| 608 | try: |
| 609 | return _io.open(fd, mode, buffering=buffering, |
| 610 | newline=newline, encoding=encoding) |
| 611 | except: |
| 612 | _os.close(fd) |
| 613 | raise |
| 614 | # Fallback to _mkstemp_inner(). |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 615 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 616 | (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 617 | try: |
| 618 | _os.unlink(name) |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 619 | return _io.open(fd, mode, buffering=buffering, |
| 620 | newline=newline, encoding=encoding) |
Guido van Rossum | 0e54871 | 2002-08-09 16:14:33 +0000 | [diff] [blame] | 621 | except: |
| 622 | _os.close(fd) |
| 623 | raise |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 624 | |
| 625 | class SpooledTemporaryFile: |
Serhiy Storchaka | 4f169a7 | 2013-02-09 11:46:42 +0200 | [diff] [blame] | 626 | """Temporary file wrapper, specialized to switch from BytesIO |
| 627 | or StringIO to a real file when it exceeds a certain size or |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 628 | when a fileno is needed. |
| 629 | """ |
| 630 | _rolled = False |
| 631 | |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 632 | def __init__(self, max_size=0, mode='w+b', buffering=-1, |
| 633 | encoding=None, newline=None, |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 634 | suffix=None, prefix=None, dir=None): |
Guido van Rossum | 9a63470 | 2007-07-09 10:24:45 +0000 | [diff] [blame] | 635 | if 'b' in mode: |
| 636 | self._file = _io.BytesIO() |
| 637 | else: |
Guido van Rossum | 5d21255 | 2007-10-29 16:42:51 +0000 | [diff] [blame] | 638 | # Setting newline="\n" avoids newline translation; |
| 639 | # this is important because otherwise on Windows we'd |
Yury Selivanov | 0b86660 | 2014-09-26 17:08:21 -0400 | [diff] [blame] | 640 | # get double newline translation upon rollover(). |
Alexandre Vassalotti | 3ade6f9 | 2008-06-12 01:13:54 +0000 | [diff] [blame] | 641 | self._file = _io.StringIO(newline="\n") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 642 | self._max_size = max_size |
| 643 | self._rolled = False |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 644 | self._TemporaryFileArgs = {'mode': mode, 'buffering': buffering, |
| 645 | 'suffix': suffix, 'prefix': prefix, |
| 646 | 'encoding': encoding, 'newline': newline, |
| 647 | 'dir': dir} |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 648 | |
| 649 | def _check(self, file): |
| 650 | if self._rolled: return |
| 651 | max_size = self._max_size |
| 652 | if max_size and file.tell() > max_size: |
| 653 | self.rollover() |
| 654 | |
| 655 | def rollover(self): |
| 656 | if self._rolled: return |
| 657 | file = self._file |
Guido van Rossum | f0c7416 | 2007-08-28 03:29:45 +0000 | [diff] [blame] | 658 | newfile = self._file = TemporaryFile(**self._TemporaryFileArgs) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 659 | del self._TemporaryFileArgs |
| 660 | |
| 661 | newfile.write(file.getvalue()) |
| 662 | newfile.seek(file.tell(), 0) |
| 663 | |
| 664 | self._rolled = True |
| 665 | |
Christian Heimes | 3ecfea71 | 2008-02-09 20:51:34 +0000 | [diff] [blame] | 666 | # The method caching trick from NamedTemporaryFile |
| 667 | # won't work here, because _file may change from a |
Serhiy Storchaka | 50254c5 | 2013-08-29 11:35:43 +0300 | [diff] [blame] | 668 | # BytesIO/StringIO instance to a real file. So we list |
Christian Heimes | 3ecfea71 | 2008-02-09 20:51:34 +0000 | [diff] [blame] | 669 | # all the methods directly. |
| 670 | |
| 671 | # Context management protocol |
| 672 | def __enter__(self): |
| 673 | if self._file.closed: |
| 674 | raise ValueError("Cannot enter context with closed file") |
| 675 | return self |
| 676 | |
| 677 | def __exit__(self, exc, value, tb): |
| 678 | self._file.close() |
| 679 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 680 | # file protocol |
| 681 | def __iter__(self): |
| 682 | return self._file.__iter__() |
| 683 | |
| 684 | def close(self): |
| 685 | self._file.close() |
| 686 | |
| 687 | @property |
| 688 | def closed(self): |
| 689 | return self._file.closed |
| 690 | |
| 691 | @property |
| 692 | def encoding(self): |
Serhiy Storchaka | bbbbe8e | 2013-02-09 12:21:14 +0200 | [diff] [blame] | 693 | try: |
| 694 | return self._file.encoding |
| 695 | except AttributeError: |
| 696 | if 'b' in self._TemporaryFileArgs['mode']: |
| 697 | raise |
| 698 | return self._TemporaryFileArgs['encoding'] |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 699 | |
| 700 | def fileno(self): |
| 701 | self.rollover() |
| 702 | return self._file.fileno() |
| 703 | |
| 704 | def flush(self): |
| 705 | self._file.flush() |
| 706 | |
| 707 | def isatty(self): |
| 708 | return self._file.isatty() |
| 709 | |
| 710 | @property |
| 711 | def mode(self): |
Serhiy Storchaka | bbbbe8e | 2013-02-09 12:21:14 +0200 | [diff] [blame] | 712 | try: |
| 713 | return self._file.mode |
| 714 | except AttributeError: |
| 715 | return self._TemporaryFileArgs['mode'] |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 716 | |
| 717 | @property |
| 718 | def name(self): |
Serhiy Storchaka | bbbbe8e | 2013-02-09 12:21:14 +0200 | [diff] [blame] | 719 | try: |
| 720 | return self._file.name |
| 721 | except AttributeError: |
| 722 | return None |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 723 | |
| 724 | @property |
| 725 | def newlines(self): |
Serhiy Storchaka | bbbbe8e | 2013-02-09 12:21:14 +0200 | [diff] [blame] | 726 | try: |
| 727 | return self._file.newlines |
| 728 | except AttributeError: |
| 729 | if 'b' in self._TemporaryFileArgs['mode']: |
| 730 | raise |
| 731 | return self._TemporaryFileArgs['newline'] |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 732 | |
| 733 | def read(self, *args): |
| 734 | return self._file.read(*args) |
| 735 | |
| 736 | def readline(self, *args): |
| 737 | return self._file.readline(*args) |
| 738 | |
| 739 | def readlines(self, *args): |
| 740 | return self._file.readlines(*args) |
| 741 | |
| 742 | def seek(self, *args): |
| 743 | self._file.seek(*args) |
| 744 | |
| 745 | @property |
| 746 | def softspace(self): |
| 747 | return self._file.softspace |
| 748 | |
| 749 | def tell(self): |
| 750 | return self._file.tell() |
| 751 | |
Antoine Pitrou | 0e86a58 | 2011-11-25 18:03:09 +0100 | [diff] [blame] | 752 | def truncate(self, size=None): |
| 753 | if size is None: |
| 754 | self._file.truncate() |
| 755 | else: |
| 756 | if size > self._max_size: |
| 757 | self.rollover() |
| 758 | self._file.truncate(size) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 759 | |
| 760 | def write(self, s): |
| 761 | file = self._file |
| 762 | rv = file.write(s) |
| 763 | self._check(file) |
| 764 | return rv |
| 765 | |
| 766 | def writelines(self, iterable): |
| 767 | file = self._file |
| 768 | rv = file.writelines(iterable) |
| 769 | self._check(file) |
| 770 | return rv |
| 771 | |
Nick Coghlan | 543af75 | 2010-10-24 11:23:25 +0000 | [diff] [blame] | 772 | |
| 773 | class TemporaryDirectory(object): |
| 774 | """Create and return a temporary directory. This has the same |
| 775 | behavior as mkdtemp but can be used as a context manager. For |
| 776 | example: |
| 777 | |
| 778 | with TemporaryDirectory() as tmpdir: |
| 779 | ... |
| 780 | |
Ezio Melotti | 30b9d5d | 2013-08-17 15:50:46 +0300 | [diff] [blame] | 781 | Upon exiting the context, the directory and everything contained |
Nick Coghlan | 543af75 | 2010-10-24 11:23:25 +0000 | [diff] [blame] | 782 | in it are removed. |
| 783 | """ |
| 784 | |
Gregory P. Smith | ad577b9 | 2015-05-22 16:18:14 -0700 | [diff] [blame] | 785 | def __init__(self, suffix=None, prefix=None, dir=None): |
Nick Coghlan | 6b22f3f | 2010-12-12 15:24:21 +0000 | [diff] [blame] | 786 | self.name = mkdtemp(suffix, prefix, dir) |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 787 | self._finalizer = _weakref.finalize( |
| 788 | self, self._cleanup, self.name, |
| 789 | warn_message="Implicitly cleaning up {!r}".format(self)) |
| 790 | |
| 791 | @classmethod |
Serhiy Storchaka | 5e193ac | 2014-09-24 13:26:25 +0300 | [diff] [blame] | 792 | def _cleanup(cls, name, warn_message): |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 793 | _shutil.rmtree(name) |
Serhiy Storchaka | 5e193ac | 2014-09-24 13:26:25 +0300 | [diff] [blame] | 794 | _warnings.warn(warn_message, ResourceWarning) |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 795 | |
Nick Coghlan | 6b22f3f | 2010-12-12 15:24:21 +0000 | [diff] [blame] | 796 | def __repr__(self): |
| 797 | return "<{} {!r}>".format(self.__class__.__name__, self.name) |
Nick Coghlan | 543af75 | 2010-10-24 11:23:25 +0000 | [diff] [blame] | 798 | |
| 799 | def __enter__(self): |
| 800 | return self.name |
| 801 | |
Nick Coghlan | 543af75 | 2010-10-24 11:23:25 +0000 | [diff] [blame] | 802 | def __exit__(self, exc, value, tb): |
| 803 | self.cleanup() |
| 804 | |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 805 | def cleanup(self): |
Serhiy Storchaka | 5e193ac | 2014-09-24 13:26:25 +0300 | [diff] [blame] | 806 | if self._finalizer.detach(): |
Serhiy Storchaka | a28632b | 2014-01-27 11:21:54 +0200 | [diff] [blame] | 807 | _shutil.rmtree(self.name) |