Google Git
Sign in
chromium / external / github.com / python / cpython / refs/tags/3.2 / . / Lib / os.py
blob: 34cbdc9311a9606b5c8612c16d1c76afb6f2a428 [file] [log] [blame]
Georg Brandlbde4ad42006-01-20 21:36:02[diff] [blame]1r"""OS routines for Mac, NT, or Posix depending on what system we're on.
Guido van Rossum31104f41992-01-14 18:28:36[diff] [blame]2
Guido van Rossum54f22ed2000-02-04 15:10:34[diff] [blame]3This exports:
Alexandre Vassalottieca20b62008-05-16 02:54:33[diff] [blame]4 - all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
5 - os.path is either posixpath or ntpath
6 - os.name is either 'posix', 'nt', 'os2' or 'ce'.
Guido van Rossum54f22ed2000-02-04 15:10:34[diff] [blame]7 - os.curdir is a string representing the current directory ('.' or ':')
8 - os.pardir is a string representing the parent directory ('..' or '::')
9 - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
Georg Brandled5b9b32008-12-05 07:45:54[diff] [blame]10 - os.extsep is the extension separator (always '.')
Guido van Rossum4b8c6ea2000-02-04 15:39:30[diff] [blame]11 - os.altsep is the alternate pathname separator (None or '/')
Guido van Rossum54f22ed2000-02-04 15:10:34[diff] [blame]12 - os.pathsep is the component separator used in $PATH etc
Guido van Rossum4b8c6ea2000-02-04 15:39:30[diff] [blame]13 - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
Guido van Rossum54f22ed2000-02-04 15:10:34[diff] [blame]14 - os.defpath is the default search path for executables
Martin v. Löwisbdec50f2004-06-08 08:29:33[diff] [blame]15 - os.devnull is the file path of the null device ('/dev/null', etc.)
Guido van Rossum31104f41992-01-14 18:28:36[diff] [blame]16
Guido van Rossum54f22ed2000-02-04 15:10:34[diff] [blame]17Programs that import and use 'os' stand a better chance of being
18portable between different platforms. Of course, they must then
19only use functions that are defined by all platforms (e.g., unlink
20and opendir), and leave all pathname manipulation to os.path
21(e.g., split and join).
22"""
Guido van Rossum31104f41992-01-14 18:28:36[diff] [blame]23
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]24#'
25
Christian Heimes45f9af32007-11-27 21:50:00[diff] [blame]26import sys, errno
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]27
28_names = sys.builtin_module_names
29
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]30# Note: more names are added to __all__ later.
Brett Cannon13962fc2008-08-18 01:45:29[diff] [blame]31__all__ = ["altsep", "curdir", "pardir", "sep", "pathsep", "linesep",
Martin v. Löwis22b457e2005-01-16 08:40:58[diff] [blame]32 "defpath", "name", "path", "devnull",
33 "SEEK_SET", "SEEK_CUR", "SEEK_END"]
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]34
35def _get_exports_list(module):
36 try:
37 return list(module.__all__)
38 except AttributeError:
39 return [n for n in dir(module) if n[0] != '_']
40
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]41if 'posix' in _names:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]42 name = 'posix'
Guido van Rossume9387ea1998-05-22 15:26:04[diff] [blame]43 linesep = '\n'
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]44 from posix import *
45 try:
46 from posix import _exit
47 except ImportError:
48 pass
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]49 import posixpath as path
Tim Petersf2715e02003-02-19 02:35:07[diff] [blame]50
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]51 import posix
52 __all__.extend(_get_exports_list(posix))
53 del posix
54
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]55elif 'nt' in _names:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]56 name = 'nt'
Guido van Rossume9387ea1998-05-22 15:26:04[diff] [blame]57 linesep = '\r\n'
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]58 from nt import *
Tim Peters6757c1e2003-01-08 21:20:57[diff] [blame]59 try:
60 from nt import _exit
61 except ImportError:
62 pass
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]63 import ntpath as path
Tim Petersf2715e02003-02-19 02:35:07[diff] [blame]64
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]65 import nt
66 __all__.extend(_get_exports_list(nt))
67 del nt
68
Guido van Rossum8e9ebfd1997-11-22 21:53:48[diff] [blame]69elif 'os2' in _names:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]70 name = 'os2'
Guido van Rossume9387ea1998-05-22 15:26:04[diff] [blame]71 linesep = '\r\n'
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]72 from os2 import *
73 try:
74 from os2 import _exit
75 except ImportError:
76 pass
Andrew MacIntyre5cef5712002-02-24 05:32:32[diff] [blame]77 if sys.version.find('EMX GCC') == -1:
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]78 import ntpath as path
Andrew MacIntyre5cef5712002-02-24 05:32:32[diff] [blame]79 else:
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]80 import os2emxpath as path
Andrew MacIntyre89f98652003-12-02 12:33:01[diff] [blame]81 from _emx_link import link
Tim Petersf2715e02003-02-19 02:35:07[diff] [blame]82
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]83 import os2
84 __all__.extend(_get_exports_list(os2))
85 del os2
86
Guido van Rossum18df5d41999-06-11 01:37:27[diff] [blame]87elif 'ce' in _names:
88 name = 'ce'
89 linesep = '\r\n'
Guido van Rossum18df5d41999-06-11 01:37:27[diff] [blame]90 from ce import *
Tim Peters6757c1e2003-01-08 21:20:57[diff] [blame]91 try:
92 from ce import _exit
93 except ImportError:
94 pass
Guido van Rossum18df5d41999-06-11 01:37:27[diff] [blame]95 # We can use the standard Windows path.
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]96 import ntpath as path
Tim Petersf2715e02003-02-19 02:35:07[diff] [blame]97
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]98 import ce
99 __all__.extend(_get_exports_list(ce))
100 del ce
101
Guido van Rossum2979b011994-08-01 11:18:30[diff] [blame]102else:
Collin Winter828f04a2007-08-31 00:04:24[diff] [blame]103 raise ImportError('no os specific module found')
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]104
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]105sys.modules['os.path'] = path
Georg Brandled5b9b32008-12-05 07:45:54[diff] [blame]106from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
107 devnull)
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]108
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]109del _names
110
Martin v. Löwis22b457e2005-01-16 08:40:58[diff] [blame]111# Python uses fixed values for the SEEK_ constants; they are mapped
112# to native constants if necessary in posixmodule.c
113SEEK_SET = 0
114SEEK_CUR = 1
115SEEK_END = 2
116
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]117#'
118
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]119# Super directory utilities.
120# (Inspired by Eric Raymond; the doc strings are mostly his)
121
Terry Reedy5a22b652010-12-02 07:05:56[diff] [blame]122def makedirs(name, mode=0o777, exist_ok=False):
123 """makedirs(path [, mode=0o777][, exist_ok=False])
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]124
Benjamin Petersonee5f1c12014-04-01 23:13:18[diff] [blame]125 Super-mkdir; create a leaf directory and all intermediate ones. Works like
126 mkdir, except that any intermediate path segment (not just the rightmost)
127 will be created if it does not exist. If the target directory already
128 exists, raise an OSError if exist_ok is False. Otherwise no exception is
Terry Reedy5a22b652010-12-02 07:05:56[diff] [blame]129 raised. This is recursive.
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]130
131 """
132 head, tail = path.split(name)
Fred Drake9f2550f2000-07-25 15:16:40[diff] [blame]133 if not tail:
134 head, tail = path.split(head)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]135 if head and tail and not path.exists(head):
Thomas Wouters89f507f2006-12-13 04:49:30[diff] [blame]136 try:
Terry Reedy5a22b652010-12-02 07:05:56[diff] [blame]137 makedirs(head, mode, exist_ok)
Guido van Rossumb940e112007-01-10 16:19:56[diff] [blame]138 except OSError as e:
Thomas Wouters89f507f2006-12-13 04:49:30[diff] [blame]139 # be happy if someone already created the path
Christian Heimes45f9af32007-11-27 21:50:00[diff] [blame]140 if e.errno != errno.EEXIST:
Thomas Wouters89f507f2006-12-13 04:49:30[diff] [blame]141 raise
Serhiy Storchaka4ab23bf2013-01-08 09:32:58[diff] [blame]142 cdir = curdir
143 if isinstance(tail, bytes):
144 cdir = bytes(curdir, 'ASCII')
145 if tail == cdir: # xxx/newdir/. exists if xxx/newdir exists
Andrew M. Kuchling6fccc8a2003-12-23 16:33:28[diff] [blame]146 return
Terry Reedy5a22b652010-12-02 07:05:56[diff] [blame]147 try:
148 mkdir(name, mode)
149 except OSError as e:
Benjamin Petersonee5f1c12014-04-01 23:13:18[diff] [blame]150 if not exist_ok or e.errno != errno.EEXIST or not path.isdir(name):
Terry Reedy5a22b652010-12-02 07:05:56[diff] [blame]151 raise
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]152
153def removedirs(name):
Fred Drakecadb9eb2002-07-02 21:28:04[diff] [blame]154 """removedirs(path)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]155
Fredrik Lundh96c1c7a2005-11-12 15:55:04[diff] [blame]156 Super-rmdir; remove a leaf directory and all empty intermediate
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]157 ones. Works like rmdir except that, if the leaf directory is
158 successfully removed, directories corresponding to rightmost path
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]159 segments will be pruned away until either the whole path is
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]160 consumed or an error occurs. Errors during this latter phase are
161 ignored -- they generally mean that a directory was not empty.
162
163 """
164 rmdir(name)
165 head, tail = path.split(name)
Fred Drake9f2550f2000-07-25 15:16:40[diff] [blame]166 if not tail:
167 head, tail = path.split(head)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]168 while head and tail:
169 try:
170 rmdir(head)
171 except error:
172 break
173 head, tail = path.split(head)
174
175def renames(old, new):
Fred Drakecadb9eb2002-07-02 21:28:04[diff] [blame]176 """renames(old, new)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]177
178 Super-rename; create directories as necessary and delete any left
179 empty. Works like rename, except creation of any intermediate
180 directories needed to make the new pathname good is attempted
181 first. After the rename, directories corresponding to rightmost
182 path segments of the old name will be pruned way until either the
183 whole path is consumed or a nonempty directory is found.
184
185 Note: this function can fail with the new directory structure made
186 if you lack permissions needed to unlink the leaf directory or
187 file.
188
189 """
190 head, tail = path.split(new)
191 if head and tail and not path.exists(head):
192 makedirs(head)
193 rename(old, new)
194 head, tail = path.split(old)
195 if head and tail:
196 try:
197 removedirs(head)
198 except error:
199 pass
200
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]201__all__.extend(["makedirs", "removedirs", "renames"])
202
Guido van Rossumd8faa362007-04-27 19:54:29[diff] [blame]203def walk(top, topdown=True, onerror=None, followlinks=False):
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]204 """Directory tree generator.
205
206 For each directory in the directory tree rooted at top (including top
207 itself, but excluding '.' and '..'), yields a 3-tuple
208
209 dirpath, dirnames, filenames
210
211 dirpath is a string, the path to the directory. dirnames is a list of
212 the names of the subdirectories in dirpath (excluding '.' and '..').
213 filenames is a list of the names of the non-directory files in dirpath.
214 Note that the names in the lists are just names, with no path components.
215 To get a full path (which begins with top) to a file or directory in
216 dirpath, do os.path.join(dirpath, name).
217
218 If optional arg 'topdown' is true or not specified, the triple for a
219 directory is generated before the triples for any of its subdirectories
220 (directories are generated top down). If topdown is false, the triple
221 for a directory is generated after the triples for all of its
222 subdirectories (directories are generated bottom up).
223
224 When topdown is true, the caller can modify the dirnames list in-place
225 (e.g., via del or slice assignment), and walk will only recurse into the
226 subdirectories whose names remain in dirnames; this can be used to prune
227 the search, or to impose a specific order of visiting. Modifying
228 dirnames when topdown is false is ineffective, since the directories in
229 dirnames have already been generated by the time dirnames itself is
230 generated.
231
Guido van Rossumbf1bef82003-05-13 18:01:19[diff] [blame]232 By default errors from the os.listdir() call are ignored. If
233 optional arg 'onerror' is specified, it should be a function; it
234 will be called with one argument, an os.error instance. It can
235 report the error to continue with the walk, or raise the exception
236 to abort the walk. Note that the filename is available as the
237 filename attribute of the exception object.
238
Guido van Rossumd8faa362007-04-27 19:54:29[diff] [blame]239 By default, os.walk does not follow symbolic links to subdirectories on
240 systems that support them. In order to get this functionality, set the
241 optional argument 'followlinks' to true.
242
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]243 Caution: if you pass a relative pathname for top, don't change the
244 current working directory between resumptions of walk. walk never
245 changes the current directory, and assumes that the client doesn't
246 either.
247
248 Example:
249
Christian Heimes5d8da202008-05-06 13:58:24[diff] [blame]250 import os
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]251 from os.path import join, getsize
Christian Heimes5d8da202008-05-06 13:58:24[diff] [blame]252 for root, dirs, files in os.walk('python/Lib/email'):
Neal Norwitz752abd02008-05-13 04:55:24[diff] [blame]253 print(root, "consumes", end="")
254 print(sum([getsize(join(root, name)) for name in files]), end="")
255 print("bytes in", len(files), "non-directory files")
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]256 if 'CVS' in dirs:
257 dirs.remove('CVS') # don't visit CVS directories
258 """
259
Benjamin Petersonf6489f92009-11-25 17:46:26[diff] [blame]260 islink, join, isdir = path.islink, path.join, path.isdir
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]261
262 # We may not have read permission for top, in which case we can't
Alexandre Vassalotti4e6531e2008-05-09 20:00:17[diff] [blame]263 # get a list of the files the directory contains. os.walk
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]264 # always suppressed the exception then, rather than blow up for a
265 # minor reason when (say) a thousand readable directories are still
266 # left to visit. That logic is copied here.
267 try:
268 # Note that listdir and error are globals in this module due
269 # to earlier import-*.
270 names = listdir(top)
Guido van Rossumb940e112007-01-10 16:19:56[diff] [blame]271 except error as err:
Guido van Rossumbf1bef82003-05-13 18:01:19[diff] [blame]272 if onerror is not None:
273 onerror(err)
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]274 return
275
276 dirs, nondirs = [], []
277 for name in names:
278 if isdir(join(top, name)):
279 dirs.append(name)
280 else:
281 nondirs.append(name)
282
283 if topdown:
284 yield top, dirs, nondirs
285 for name in dirs:
Benjamin Petersonf6489f92009-11-25 17:46:26[diff] [blame]286 new_path = join(top, name)
287 if followlinks or not islink(new_path):
288 for x in walk(new_path, topdown, onerror, followlinks):
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]289 yield x
290 if not topdown:
291 yield top, dirs, nondirs
292
293__all__.append("walk")
294
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]295# Make sure os.environ exists, at least
296try:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]297 environ
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]298except NameError:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]299 environ = {}
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]300
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]301def execl(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]302 """execl(file, *args)
303
304 Execute the executable file with argument list args, replacing the
305 current process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]306 execv(file, args)
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]307
308def execle(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]309 """execle(file, *args, env)
310
311 Execute the executable file with argument list args and
312 environment env, replacing the current process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]313 env = args[-1]
314 execve(file, args[:-1], env)
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]315
316def execlp(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]317 """execlp(file, *args)
318
319 Execute the executable file (which is searched for along $PATH)
320 with argument list args, replacing the current process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]321 execvp(file, args)
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]322
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]323def execlpe(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]324 """execlpe(file, *args, env)
325
326 Execute the executable file (which is searched for along $PATH)
327 with argument list args and environment env, replacing the current
Tim Peters2344fae2001-01-15 00:50:52[diff] [blame]328 process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]329 env = args[-1]
330 execvpe(file, args[:-1], env)
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]331
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]332def execvp(file, args):
Matthias Klosea09c54f2010-01-31 16:48:44[diff] [blame]333 """execvp(file, args)
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]334
335 Execute the executable file (which is searched for along $PATH)
336 with argument list args, replacing the current process.
Thomas Wouters7e474022000-07-16 12:04:32[diff] [blame]337 args may be a list or tuple of strings. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]338 _execvpe(file, args)
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]339
340def execvpe(file, args, env):
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]341 """execvpe(file, args, env)
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]342
343 Execute the executable file (which is searched for along $PATH)
344 with argument list args and environment env , replacing the
345 current process.
Tim Peters2344fae2001-01-15 00:50:52[diff] [blame]346 args may be a list or tuple of strings. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]347 _execvpe(file, args, env)
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]348
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]349__all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])
350
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]351def _execvpe(file, args, env=None):
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]352 if env is not None:
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]353 exec_func = execve
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]354 argrest = (args, env)
355 else:
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]356 exec_func = execv
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]357 argrest = (args,)
358 env = environ
Guido van Rossumaed51d82002-08-05 16:13:24[diff] [blame]359
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]360 head, tail = path.split(file)
361 if head:
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]362 exec_func(file, *argrest)
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]363 return
Guido van Rossume7ba4952007-06-06 23:52:48[diff] [blame]364 last_exc = saved_exc = None
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]365 saved_tb = None
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]366 path_list = get_exec_path(env)
367 if name != 'nt':
368 file = fsencode(file)
369 path_list = map(fsencode, path_list)
370 for dir in path_list:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]371 fullname = path.join(dir, file)
372 try:
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]373 exec_func(fullname, *argrest)
Guido van Rossumb940e112007-01-10 16:19:56[diff] [blame]374 except error as e:
Guido van Rossume7ba4952007-06-06 23:52:48[diff] [blame]375 last_exc = e
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]376 tb = sys.exc_info()[2]
Christian Heimes45f9af32007-11-27 21:50:00[diff] [blame]377 if (e.errno != errno.ENOENT and e.errno != errno.ENOTDIR
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]378 and saved_exc is None):
379 saved_exc = e
380 saved_tb = tb
381 if saved_exc:
Benjamin Peterson4b068192009-02-20 03:19:25[diff] [blame]382 raise saved_exc.with_traceback(saved_tb)
383 raise last_exc.with_traceback(tb)
Guido van Rossumd74fb6b2001-03-02 06:43:49[diff] [blame]384
Guido van Rossumcd16bf62007-06-13 18:07:49[diff] [blame]385
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]386def get_exec_path(env=None):
387 """Returns the sequence of directories that will be searched for the
388 named executable (similar to a shell) when launching a process.
389
390 *env* must be an environment variable dict or None. If *env* is None,
391 os.environ will be used.
392 """
Victor Stinner273b7662010-11-06 12:59:33[diff] [blame]393 # Use a local import instead of a global import to limit the number of
394 # modules loaded at startup: the os module is always loaded at startup by
395 # Python. It may also avoid a bootstrap issue.
Victor Stinner6f35eda2010-10-29 00:38:58[diff] [blame]396 import warnings
397
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]398 if env is None:
399 env = environ
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]400
Victor Stinnerbb4f2182010-11-07 15:43:39[diff] [blame]401 # {b'PATH': ...}.get('PATH') and {'PATH': ...}.get(b'PATH') emit a
402 # BytesWarning when using python -b or python -bb: ignore the warning
Victor Stinner273b7662010-11-06 12:59:33[diff] [blame]403 with warnings.catch_warnings():
404 warnings.simplefilter("ignore", BytesWarning)
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]405
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]406 try:
Victor Stinner273b7662010-11-06 12:59:33[diff] [blame]407 path_list = env.get('PATH')
408 except TypeError:
409 path_list = None
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]410
Victor Stinner273b7662010-11-06 12:59:33[diff] [blame]411 if supports_bytes_environ:
412 try:
413 path_listb = env[b'PATH']
414 except (KeyError, TypeError):
415 pass
416 else:
417 if path_list is not None:
418 raise ValueError(
419 "env cannot contain 'PATH' and b'PATH' keys")
420 path_list = path_listb
421
422 if path_list is not None and isinstance(path_list, bytes):
423 path_list = fsdecode(path_list)
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]424
425 if path_list is None:
426 path_list = defpath
427 return path_list.split(pathsep)
Gregory P. Smithb6e8c7e2010-02-27 07:22:22[diff] [blame]428
429
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]430# Change environ to automatically call putenv(), unsetenv if they exist.
431from _abcoll import MutableMapping # Can't use collections (bootstrap)
432
433class _Environ(MutableMapping):
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]434 def __init__(self, data, encodekey, decodekey, encodevalue, decodevalue, putenv, unsetenv):
435 self.encodekey = encodekey
436 self.decodekey = decodekey
437 self.encodevalue = encodevalue
438 self.decodevalue = decodevalue
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]439 self.putenv = putenv
440 self.unsetenv = unsetenv
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]441 self._data = data
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]442
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]443 def __getitem__(self, key):
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]444 value = self._data[self.encodekey(key)]
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]445 return self.decodevalue(value)
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]446
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]447 def __setitem__(self, key, value):
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]448 key = self.encodekey(key)
449 value = self.encodevalue(value)
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]450 self.putenv(key, value)
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]451 self._data[key] = value
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]452
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]453 def __delitem__(self, key):
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]454 key = self.encodekey(key)
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]455 self.unsetenv(key)
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]456 del self._data[key]
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]457
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]458 def __iter__(self):
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]459 for key in self._data:
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]460 yield self.decodekey(key)
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]461
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]462 def __len__(self):
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]463 return len(self._data)
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]464
465 def __repr__(self):
Victor Stinnerbed71172010-07-28 21:25:42[diff] [blame]466 return 'environ({{{}}})'.format(', '.join(
Victor Stinnerd73c1a32010-07-28 21:23:23[diff] [blame]467 ('{!r}: {!r}'.format(self.decodekey(key), self.decodevalue(value))
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]468 for key, value in self._data.items())))
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]469
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]470 def copy(self):
471 return dict(self)
Ezio Melotti19e4acf2010-02-22 15:59:01[diff] [blame]472
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]473 def setdefault(self, key, value):
474 if key not in self:
475 self[key] = value
476 return self[key]
477
478try:
479 _putenv = putenv
480except NameError:
481 _putenv = lambda key, value: None
Martin v. Löwisa90f4382001-03-07 09:05:45[diff] [blame]482else:
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]483 __all__.append("putenv")
Guido van Rossum3b8e20d1996-07-24 00:55:17[diff] [blame]484
Skip Montanaro289bc052007-08-17 02:30:27[diff] [blame]485try:
486 _unsetenv = unsetenv
487except NameError:
488 _unsetenv = lambda key: _putenv(key, "")
489else:
490 __all__.append("unsetenv")
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]491
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]492def _createenviron():
493 if name in ('os2', 'nt'):
494 # Where Env Var Names Must Be UPPERCASE
495 def check_str(value):
496 if not isinstance(value, str):
497 raise TypeError("str expected, not %s" % type(value).__name__)
498 return value
499 encode = check_str
500 decode = str
501 def encodekey(key):
502 return encode(key).upper()
503 data = {}
504 for key, value in environ.items():
505 data[encodekey(key)] = value
506 else:
507 # Where Env Var Names Can Be Mixed Case
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]508 encoding = sys.getfilesystemencoding()
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]509 def encode(value):
510 if not isinstance(value, str):
511 raise TypeError("str expected, not %s" % type(value).__name__)
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]512 return value.encode(encoding, 'surrogateescape')
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]513 def decode(value):
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]514 return value.decode(encoding, 'surrogateescape')
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]515 encodekey = encode
516 data = environ
517 return _Environ(data,
518 encodekey, decode,
519 encode, decode,
520 _putenv, _unsetenv)
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]521
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]522# unicode environ
523environ = _createenviron()
524del _createenviron
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]525
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]526
Jack Jansenb11ce9b2003-01-08 16:33:40[diff] [blame]527def getenv(key, default=None):
Tim Peters2c60f7a2003-01-29 03:49:43[diff] [blame]528 """Get an environment variable, return None if it doesn't exist.
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]529 The optional second argument can specify an alternate default.
530 key, default and the result are str."""
Tim Peters2c60f7a2003-01-29 03:49:43[diff] [blame]531 return environ.get(key, default)
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]532
Victor Stinnerb745a742010-05-18 17:17:23[diff] [blame]533supports_bytes_environ = name not in ('os2', 'nt')
534__all__.extend(("getenv", "supports_bytes_environ"))
535
536if supports_bytes_environ:
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]537 def _check_bytes(value):
538 if not isinstance(value, bytes):
539 raise TypeError("bytes expected, not %s" % type(value).__name__)
540 return value
541
542 # bytes environ
Victor Stinner3d75d0c2010-09-10 22:18:16[diff] [blame]543 environb = _Environ(environ._data,
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]544 _check_bytes, bytes,
545 _check_bytes, bytes,
546 _putenv, _unsetenv)
547 del _check_bytes
548
549 def getenvb(key, default=None):
550 """Get an environment variable, return None if it doesn't exist.
551 The optional second argument can specify an alternate default.
552 key, default and the result are bytes."""
553 return environb.get(key, default)
Victor Stinner70120e22010-07-29 17:19:38[diff] [blame]554
555 __all__.extend(("environb", "getenvb"))
Victor Stinner84ae1182010-05-06 22:05:07[diff] [blame]556
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]557def _fscodec():
558 encoding = sys.getfilesystemencoding()
559 if encoding == 'mbcs':
Victor Stinnere882aac2010-10-24 21:12:26[diff] [blame]560 errors = 'strict'
Victor Stinner313a1202010-06-11 23:56:51[diff] [blame]561 else:
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]562 errors = 'surrogateescape'
Victor Stinnere8d51452010-08-19 01:05:19[diff] [blame]563
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]564 def fsencode(filename):
565 """
566 Encode filename to the filesystem encoding with 'surrogateescape' error
567 handler, return bytes unchanged. On Windows, use 'strict' error handler if
568 the file system encoding is 'mbcs' (which is the default encoding).
569 """
570 if isinstance(filename, bytes):
571 return filename
572 elif isinstance(filename, str):
573 return filename.encode(encoding, errors)
Victor Stinnere8d51452010-08-19 01:05:19[diff] [blame]574 else:
Victor Stinnerdf6d6cb2010-10-24 20:32:26[diff] [blame]575 raise TypeError("expect bytes or str, not %s" % type(filename).__name__)
576
577 def fsdecode(filename):
578 """
579 Decode filename from the filesystem encoding with 'surrogateescape' error
580 handler, return str unchanged. On Windows, use 'strict' error handler if
581 the file system encoding is 'mbcs' (which is the default encoding).
582 """
583 if isinstance(filename, str):
584 return filename
585 elif isinstance(filename, bytes):
586 return filename.decode(encoding, errors)
587 else:
588 raise TypeError("expect bytes or str, not %s" % type(filename).__name__)
589
590 return fsencode, fsdecode
591
592fsencode, fsdecode = _fscodec()
593del _fscodec
Victor Stinner449c4662010-05-08 11:10:09[diff] [blame]594
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]595def _exists(name):
Benjamin Peterson87c8d872009-06-11 22:54:11[diff] [blame]596 return name in globals()
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]597
598# Supply spawn*() (probably only for Unix)
599if _exists("fork") and not _exists("spawnv") and _exists("execv"):
600
601 P_WAIT = 0
602 P_NOWAIT = P_NOWAITO = 1
603
604 # XXX Should we support P_DETACH? I suppose it could fork()**2
605 # and close the std I/O streams. Also, P_OVERLAY is the same
606 # as execv*()?
607
608 def _spawnvef(mode, file, args, env, func):
609 # Internal helper; func is the exec*() function to use
610 pid = fork()
611 if not pid:
612 # Child
613 try:
614 if env is None:
615 func(file, args)
616 else:
617 func(file, args, env)
618 except:
619 _exit(127)
620 else:
621 # Parent
622 if mode == P_NOWAIT:
623 return pid # Caller is responsible for waiting!
624 while 1:
625 wpid, sts = waitpid(pid, 0)
626 if WIFSTOPPED(sts):
627 continue
628 elif WIFSIGNALED(sts):
629 return -WTERMSIG(sts)
630 elif WIFEXITED(sts):
631 return WEXITSTATUS(sts)
632 else:
Collin Winter828f04a2007-08-31 00:04:24[diff] [blame]633 raise error("Not stopped, signaled or exited???")
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]634
635 def spawnv(mode, file, args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]636 """spawnv(mode, file, args) -> integer
637
638Execute file with arguments from args in a subprocess.
639If mode == P_NOWAIT return the pid of the process.
640If mode == P_WAIT return the process's exit code if it exits normally;
Tim Peters2344fae2001-01-15 00:50:52[diff] [blame]641otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]642 return _spawnvef(mode, file, args, None, execv)
643
644 def spawnve(mode, file, args, env):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]645 """spawnve(mode, file, args, env) -> integer
646
647Execute file with arguments from args in a subprocess with the
648specified environment.
649If mode == P_NOWAIT return the pid of the process.
650If mode == P_WAIT return the process's exit code if it exits normally;
651otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]652 return _spawnvef(mode, file, args, env, execve)
653
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]654 # Note: spawnvp[e] is't currently supported on Windows
655
656 def spawnvp(mode, file, args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]657 """spawnvp(mode, file, args) -> integer
658
659Execute file (which is looked for along $PATH) with arguments from
660args in a subprocess.
661If mode == P_NOWAIT return the pid of the process.
662If mode == P_WAIT return the process's exit code if it exits normally;
663otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]664 return _spawnvef(mode, file, args, None, execvp)
665
666 def spawnvpe(mode, file, args, env):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]667 """spawnvpe(mode, file, args, env) -> integer
668
669Execute file (which is looked for along $PATH) with arguments from
670args in a subprocess with the supplied environment.
671If mode == P_NOWAIT return the pid of the process.
672If mode == P_WAIT return the process's exit code if it exits normally;
673otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]674 return _spawnvef(mode, file, args, env, execvpe)
675
676if _exists("spawnv"):
677 # These aren't supplied by the basic Windows code
678 # but can be easily implemented in Python
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]679
680 def spawnl(mode, file, *args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]681 """spawnl(mode, file, *args) -> integer
682
683Execute file with arguments from args in a subprocess.
684If mode == P_NOWAIT return the pid of the process.
685If mode == P_WAIT return the process's exit code if it exits normally;
686otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]687 return spawnv(mode, file, args)
688
689 def spawnle(mode, file, *args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]690 """spawnle(mode, file, *args, env) -> integer
691
692Execute file with arguments from args in a subprocess with the
693supplied environment.
694If mode == P_NOWAIT return the pid of the process.
695If mode == P_WAIT return the process's exit code if it exits normally;
696otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]697 env = args[-1]
698 return spawnve(mode, file, args[:-1], env)
699
Andrew MacIntyre69e18c92004-04-04 07:11:43[diff] [blame]700
701 __all__.extend(["spawnv", "spawnve", "spawnl", "spawnle",])
702
703
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]704if _exists("spawnvp"):
705 # At the moment, Windows doesn't implement spawnvp[e],
706 # so it won't have spawnlp[e] either.
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]707 def spawnlp(mode, file, *args):
Neal Norwitzb7f68102003-07-02 02:49:33[diff] [blame]708 """spawnlp(mode, file, *args) -> integer
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]709
710Execute file (which is looked for along $PATH) with arguments from
711args in a subprocess with the supplied environment.
712If mode == P_NOWAIT return the pid of the process.
713If mode == P_WAIT return the process's exit code if it exits normally;
714otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]715 return spawnvp(mode, file, args)
716
717 def spawnlpe(mode, file, *args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]718 """spawnlpe(mode, file, *args, env) -> integer
719
720Execute file (which is looked for along $PATH) with arguments from
721args in a subprocess with the supplied environment.
722If mode == P_NOWAIT return the pid of the process.
723If mode == P_WAIT return the process's exit code if it exits normally;
724otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]725 env = args[-1]
726 return spawnvpe(mode, file, args[:-1], env)
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]727
728
Andrew MacIntyre69e18c92004-04-04 07:11:43[diff] [blame]729 __all__.extend(["spawnvp", "spawnvpe", "spawnlp", "spawnlpe",])
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]730
Alexandre Vassalottif7fa63d2008-05-11 08:55:36[diff] [blame]731import copyreg as _copyreg
Michael W. Hudson0e025302002-03-06 17:11:18[diff] [blame]732
733def _make_stat_result(tup, dict):
734 return stat_result(tup, dict)
735
736def _pickle_stat_result(sr):
737 (type, args) = sr.__reduce__()
738 return (_make_stat_result, args)
739
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]740try:
Alexandre Vassalottif7fa63d2008-05-11 08:55:36[diff] [blame]741 _copyreg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]742except NameError: # stat_result may not exist
743 pass
Michael W. Hudson0e025302002-03-06 17:11:18[diff] [blame]744
745def _make_statvfs_result(tup, dict):
746 return statvfs_result(tup, dict)
747
748def _pickle_statvfs_result(sr):
749 (type, args) = sr.__reduce__()
750 return (_make_statvfs_result, args)
751
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]752try:
Alexandre Vassalottif7fa63d2008-05-11 08:55:36[diff] [blame]753 _copyreg.pickle(statvfs_result, _pickle_statvfs_result,
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]754 _make_statvfs_result)
Michael W. Hudsone5363b72002-03-15 10:21:59[diff] [blame]755except NameError: # statvfs_result may not exist
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]756 pass
Martin v. Löwisdc3883f2004-08-29 15:46:35[diff] [blame]757
Guido van Rossumc2f93dc2007-05-24 00:50:02[diff] [blame]758# Supply os.popen()
Antoine Pitrou877766d2011-03-19 16:00:37[diff] [blame]759def popen(cmd, mode="r", buffering=-1):
Guido van Rossum3172c5d2007-10-16 18:12:55[diff] [blame]760 if not isinstance(cmd, str):
Guido van Rossumc2f93dc2007-05-24 00:50:02[diff] [blame]761 raise TypeError("invalid cmd type (%s, expected string)" % type(cmd))
762 if mode not in ("r", "w"):
763 raise ValueError("invalid mode %r" % mode)
Antoine Pitrou877766d2011-03-19 16:00:37[diff] [blame]764 if buffering == 0 or buffering == None:
765 raise ValueError("popen() does not support unbuffered streams")
Guido van Rossumc2f93dc2007-05-24 00:50:02[diff] [blame]766 import subprocess, io
767 if mode == "r":
768 proc = subprocess.Popen(cmd,
769 shell=True,
770 stdout=subprocess.PIPE,
771 bufsize=buffering)
772 return _wrap_close(io.TextIOWrapper(proc.stdout), proc)
773 else:
774 proc = subprocess.Popen(cmd,
775 shell=True,
776 stdin=subprocess.PIPE,
777 bufsize=buffering)
778 return _wrap_close(io.TextIOWrapper(proc.stdin), proc)
779
780# Helper for popen() -- a proxy for a file whose close waits for the process
781class _wrap_close:
782 def __init__(self, stream, proc):
783 self._stream = stream
784 self._proc = proc
785 def close(self):
786 self._stream.close()
Amaury Forgeot d'Arc97e5f282009-07-11 09:35:13[diff] [blame]787 returncode = self._proc.wait()
788 if returncode == 0:
789 return None
790 if name == 'nt':
791 return returncode
792 else:
793 return returncode << 8 # Shift left to match old behavior
Antoine Pitrouac625352009-12-09 00:01:27[diff] [blame]794 def __enter__(self):
795 return self
796 def __exit__(self, *args):
797 self.close()
Guido van Rossumc2f93dc2007-05-24 00:50:02[diff] [blame]798 def __getattr__(self, name):
799 return getattr(self._stream, name)
Thomas Heller476157b2007-09-04 11:27:47[diff] [blame]800 def __iter__(self):
801 return iter(self._stream)
Guido van Rossumc2f93dc2007-05-24 00:50:02[diff] [blame]802
Amaury Forgeot d'Arcbdbddf82008-08-01 00:06:49[diff] [blame]803# Supply os.fdopen()
804def fdopen(fd, *args, **kwargs):
Guido van Rossumc2f93dc2007-05-24 00:50:02[diff] [blame]805 if not isinstance(fd, int):
806 raise TypeError("invalid fd type (%s, expected integer)" % type(fd))
807 import io
Amaury Forgeot d'Arcbdbddf82008-08-01 00:06:49[diff] [blame]808 return io.open(fd, *args, **kwargs)