Google Git
Sign in
chromium / external / github.com / python / cpython / refs/tags/2.7 / . / Lib / os.py
blob: cfea71be91b38517c6d01b834bcfb034ef8087af [file] [log] [blame]
Ned Deily5937f392014-06-27 06:38:14[diff] [blame]1r"""OS routines for 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:
Ronald Oussoren81af68e2008-05-12 11:24:33[diff] [blame]4 - all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
5 - os.path is one of the modules posixpath, or ntpath
6 - os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
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 '\\')
Guido van Rossume2ae77b2001-10-24 20:42:55[diff] [blame]10 - os.extsep is the extension separator ('.' or '/')
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
Facundo Batista2ffd7802007-11-27 18:50:12[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 Cannon88f801d2008-08-18 00:46:22[diff] [blame]31__all__ = ["altsep", "curdir", "pardir", "sep", "extsep", "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 Rossumd74fb6b2001-03-02 06:43:49[diff] [blame]102elif 'riscos' in _names:
103 name = 'riscos'
104 linesep = '\n'
Guido van Rossumd74fb6b2001-03-02 06:43:49[diff] [blame]105 from riscos import *
106 try:
107 from riscos import _exit
108 except ImportError:
109 pass
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]110 import riscospath as path
Tim Petersf2715e02003-02-19 02:35:07[diff] [blame]111
Guido van Rossumd74fb6b2001-03-02 06:43:49[diff] [blame]112 import riscos
113 __all__.extend(_get_exports_list(riscos))
Skip Montanaro81e4b1c2001-03-06 15:26:07[diff] [blame]114 del riscos
Guido van Rossumd74fb6b2001-03-02 06:43:49[diff] [blame]115
Guido van Rossum2979b011994-08-01 11:18:30[diff] [blame]116else:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]117 raise ImportError, 'no os specific module found'
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]118
Skip Montanaro117910d2003-02-14 19:35:31[diff] [blame]119sys.modules['os.path'] = path
Tim Peters3b2cdad2004-09-01 13:10:32[diff] [blame]120from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
Andrew M. Kuchling33ad28b2004-08-31 11:38:12[diff] [blame]121 devnull)
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]122
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]123del _names
124
Martin v. Löwis22b457e2005-01-16 08:40:58[diff] [blame]125# Python uses fixed values for the SEEK_ constants; they are mapped
126# to native constants if necessary in posixmodule.c
127SEEK_SET = 0
128SEEK_CUR = 1
129SEEK_END = 2
130
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]131#'
132
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]133# Super directory utilities.
134# (Inspired by Eric Raymond; the doc strings are mostly his)
135
136def makedirs(name, mode=0777):
Fred Drakecadb9eb2002-07-02 21:28:04[diff] [blame]137 """makedirs(path [, mode=0777])
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]138
139 Super-mkdir; create a leaf directory and all intermediate ones.
140 Works like mkdir, except that any intermediate path segment (not
141 just the rightmost) will be created if it does not exist. This is
142 recursive.
143
144 """
145 head, tail = path.split(name)
Fred Drake9f2550f2000-07-25 15:16:40[diff] [blame]146 if not tail:
147 head, tail = path.split(head)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]148 if head and tail and not path.exists(head):
Georg Brandlb1307432006-12-09 09:08:29[diff] [blame]149 try:
150 makedirs(head, mode)
151 except OSError, e:
152 # be happy if someone already created the path
Facundo Batista2ffd7802007-11-27 18:50:12[diff] [blame]153 if e.errno != errno.EEXIST:
Georg Brandlb1307432006-12-09 09:08:29[diff] [blame]154 raise
Andrew M. Kuchling6fccc8a2003-12-23 16:33:28[diff] [blame]155 if tail == curdir: # xxx/newdir/. exists if xxx/newdir exists
156 return
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]157 mkdir(name, mode)
158
159def removedirs(name):
Fred Drakecadb9eb2002-07-02 21:28:04[diff] [blame]160 """removedirs(path)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]161
Fredrik Lundh96c1c7a2005-11-12 15:55:04[diff] [blame]162 Super-rmdir; remove a leaf directory and all empty intermediate
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]163 ones. Works like rmdir except that, if the leaf directory is
164 successfully removed, directories corresponding to rightmost path
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]165 segments will be pruned away until either the whole path is
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]166 consumed or an error occurs. Errors during this latter phase are
167 ignored -- they generally mean that a directory was not empty.
168
169 """
170 rmdir(name)
171 head, tail = path.split(name)
Fred Drake9f2550f2000-07-25 15:16:40[diff] [blame]172 if not tail:
173 head, tail = path.split(head)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]174 while head and tail:
175 try:
176 rmdir(head)
177 except error:
178 break
179 head, tail = path.split(head)
180
181def renames(old, new):
Fred Drakecadb9eb2002-07-02 21:28:04[diff] [blame]182 """renames(old, new)
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]183
184 Super-rename; create directories as necessary and delete any left
185 empty. Works like rename, except creation of any intermediate
186 directories needed to make the new pathname good is attempted
187 first. After the rename, directories corresponding to rightmost
Benjamin Petersonb0368492015-04-14 00:24:10[diff] [blame]188 path segments of the old name will be pruned until either the
Guido van Rossum4def7de1998-07-24 20:48:03[diff] [blame]189 whole path is consumed or a nonempty directory is found.
190
191 Note: this function can fail with the new directory structure made
192 if you lack permissions needed to unlink the leaf directory or
193 file.
194
195 """
196 head, tail = path.split(new)
197 if head and tail and not path.exists(head):
198 makedirs(head)
199 rename(old, new)
200 head, tail = path.split(old)
201 if head and tail:
202 try:
203 removedirs(head)
204 except error:
205 pass
206
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]207__all__.extend(["makedirs", "removedirs", "renames"])
208
Georg Brandlcae9f3d2007-03-21 09:10:29[diff] [blame]209def walk(top, topdown=True, onerror=None, followlinks=False):
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]210 """Directory tree generator.
211
212 For each directory in the directory tree rooted at top (including top
213 itself, but excluding '.' and '..'), yields a 3-tuple
214
215 dirpath, dirnames, filenames
216
217 dirpath is a string, the path to the directory. dirnames is a list of
218 the names of the subdirectories in dirpath (excluding '.' and '..').
219 filenames is a list of the names of the non-directory files in dirpath.
220 Note that the names in the lists are just names, with no path components.
221 To get a full path (which begins with top) to a file or directory in
222 dirpath, do os.path.join(dirpath, name).
223
224 If optional arg 'topdown' is true or not specified, the triple for a
225 directory is generated before the triples for any of its subdirectories
226 (directories are generated top down). If topdown is false, the triple
227 for a directory is generated after the triples for all of its
228 subdirectories (directories are generated bottom up).
229
230 When topdown is true, the caller can modify the dirnames list in-place
231 (e.g., via del or slice assignment), and walk will only recurse into the
Benjamin Peterson87d01362014-06-16 03:51:12[diff] [blame]232 subdirectories whose names remain in dirnames; this can be used to prune the
233 search, or to impose a specific order of visiting. Modifying dirnames when
234 topdown is false is ineffective, since the directories in dirnames have
235 already been generated by the time dirnames itself is generated. No matter
236 the value of topdown, the list of subdirectories is retrieved before the
237 tuples for the directory and its subdirectories are generated.
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]238
Guido van Rossumbf1bef82003-05-13 18:01:19[diff] [blame]239 By default errors from the os.listdir() call are ignored. If
240 optional arg 'onerror' is specified, it should be a function; it
241 will be called with one argument, an os.error instance. It can
242 report the error to continue with the walk, or raise the exception
243 to abort the walk. Note that the filename is available as the
244 filename attribute of the exception object.
245
Georg Brandlcae9f3d2007-03-21 09:10:29[diff] [blame]246 By default, os.walk does not follow symbolic links to subdirectories on
247 systems that support them. In order to get this functionality, set the
248 optional argument 'followlinks' to true.
249
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]250 Caution: if you pass a relative pathname for top, don't change the
251 current working directory between resumptions of walk. walk never
252 changes the current directory, and assumes that the client doesn't
253 either.
254
255 Example:
256
Gregory P. Smith8e499732008-05-06 07:05:18[diff] [blame]257 import os
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]258 from os.path import join, getsize
Gregory P. Smith8e499732008-05-06 07:05:18[diff] [blame]259 for root, dirs, files in os.walk('python/Lib/email'):
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]260 print root, "consumes",
261 print sum([getsize(join(root, name)) for name in files]),
262 print "bytes in", len(files), "non-directory files"
263 if 'CVS' in dirs:
264 dirs.remove('CVS') # don't visit CVS directories
Benjamin Peterson87d01362014-06-16 03:51:12[diff] [blame]265
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]266 """
267
Benjamin Peterson246ec332009-11-20 02:56:43[diff] [blame]268 islink, join, isdir = path.islink, path.join, path.isdir
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]269
270 # We may not have read permission for top, in which case we can't
271 # get a list of the files the directory contains. os.path.walk
272 # always suppressed the exception then, rather than blow up for a
273 # minor reason when (say) a thousand readable directories are still
274 # left to visit. That logic is copied here.
275 try:
276 # Note that listdir and error are globals in this module due
277 # to earlier import-*.
278 names = listdir(top)
Guido van Rossumbf1bef82003-05-13 18:01:19[diff] [blame]279 except error, err:
280 if onerror is not None:
281 onerror(err)
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]282 return
283
284 dirs, nondirs = [], []
285 for name in names:
286 if isdir(join(top, name)):
287 dirs.append(name)
288 else:
289 nondirs.append(name)
290
291 if topdown:
292 yield top, dirs, nondirs
293 for name in dirs:
Benjamin Peterson246ec332009-11-20 02:56:43[diff] [blame]294 new_path = join(top, name)
295 if followlinks or not islink(new_path):
296 for x in walk(new_path, topdown, onerror, followlinks):
Tim Petersc4e09402003-04-25 07:11:48[diff] [blame]297 yield x
298 if not topdown:
299 yield top, dirs, nondirs
300
301__all__.append("walk")
302
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]303# Make sure os.environ exists, at least
304try:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]305 environ
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]306except NameError:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]307 environ = {}
Guido van Rossuma28dab51997-08-29 22:36:47[diff] [blame]308
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]309def execl(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]310 """execl(file, *args)
311
312 Execute the executable file with argument list args, replacing the
313 current process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]314 execv(file, args)
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]315
316def execle(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]317 """execle(file, *args, env)
318
319 Execute the executable file with argument list args and
320 environment env, replacing the current process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]321 env = args[-1]
322 execve(file, args[:-1], env)
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]323
324def execlp(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]325 """execlp(file, *args)
326
327 Execute the executable file (which is searched for along $PATH)
328 with argument list args, replacing the current process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]329 execvp(file, args)
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]330
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]331def execlpe(file, *args):
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]332 """execlpe(file, *args, env)
333
334 Execute the executable file (which is searched for along $PATH)
335 with argument list args and environment env, replacing the current
Tim Peters2344fae2001-01-15 00:50:52[diff] [blame]336 process. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]337 env = args[-1]
338 execvpe(file, args[:-1], env)
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]339
Guido van Rossume65cce51993-11-08 15:05:21[diff] [blame]340def execvp(file, args):
Matthias Klose48a3c4e2010-01-31 16:46:26[diff] [blame]341 """execvp(file, args)
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, replacing the current process.
Thomas Wouters7e474022000-07-16 12:04:32[diff] [blame]345 args may be a list or tuple of strings. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]346 _execvpe(file, args)
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]347
348def execvpe(file, args, env):
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]349 """execvpe(file, args, env)
Guido van Rossum7da3cc52000-04-25 10:53:22[diff] [blame]350
351 Execute the executable file (which is searched for along $PATH)
352 with argument list args and environment env , replacing the
353 current process.
Tim Peters2344fae2001-01-15 00:50:52[diff] [blame]354 args may be a list or tuple of strings. """
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]355 _execvpe(file, args, env)
Guido van Rossum030afb11995-03-14 17:27:18[diff] [blame]356
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]357__all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])
358
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]359def _execvpe(file, args, env=None):
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]360 if env is not None:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]361 func = execve
362 argrest = (args, env)
363 else:
364 func = execv
365 argrest = (args,)
366 env = environ
Guido van Rossumaed51d82002-08-05 16:13:24[diff] [blame]367
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]368 head, tail = path.split(file)
369 if head:
Guido van Rossum68468eb2003-02-27 20:14:51[diff] [blame]370 func(file, *argrest)
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]371 return
Raymond Hettinger54f02222002-06-01 14:18:47[diff] [blame]372 if 'PATH' in env:
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]373 envpath = env['PATH']
374 else:
375 envpath = defpath
Guido van Rossum965fdae2000-04-04 19:50:04[diff] [blame]376 PATH = envpath.split(pathsep)
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]377 saved_exc = None
378 saved_tb = None
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]379 for dir in PATH:
380 fullname = path.join(dir, file)
381 try:
Guido van Rossum68468eb2003-02-27 20:14:51[diff] [blame]382 func(fullname, *argrest)
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]383 except error, e:
384 tb = sys.exc_info()[2]
Facundo Batista2ffd7802007-11-27 18:50:12[diff] [blame]385 if (e.errno != errno.ENOENT and e.errno != errno.ENOTDIR
Guido van Rossum683c0fe2002-09-03 16:36:17[diff] [blame]386 and saved_exc is None):
387 saved_exc = e
388 saved_tb = tb
389 if saved_exc:
390 raise error, saved_exc, saved_tb
391 raise error, e, tb
Guido van Rossumd74fb6b2001-03-02 06:43:49[diff] [blame]392
Martin v. Löwisa90f4382001-03-07 09:05:45[diff] [blame]393# Change environ to automatically call putenv() if it exists
394try:
395 # This will fail if there's no putenv
396 putenv
397except NameError:
398 pass
399else:
400 import UserDict
Guido van Rossum3b8e20d1996-07-24 00:55:17[diff] [blame]401
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]402 # Fake unsetenv() for Windows
Martin v. Löwis8b10f892002-10-09 17:23:29[diff] [blame]403 # not sure about os2 here but
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]404 # I'm guessing they are the same.
405
Martin v. Löwis8b10f892002-10-09 17:23:29[diff] [blame]406 if name in ('os2', 'nt'):
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]407 def unsetenv(key):
408 putenv(key, "")
409
Martin v. Löwisa90f4382001-03-07 09:05:45[diff] [blame]410 if name == "riscos":
411 # On RISC OS, all env access goes through getenv and putenv
412 from riscosenviron import _Environ
Martin v. Löwis8b10f892002-10-09 17:23:29[diff] [blame]413 elif name in ('os2', 'nt'): # Where Env Var Names Must Be UPPERCASE
Guido van Rossumda4d6da1998-08-04 16:01:23[diff] [blame]414 # But we store them as upper case
Raymond Hettingerca2f5372002-09-06 19:36:31[diff] [blame]415 class _Environ(UserDict.IterableUserDict):
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]416 def __init__(self, environ):
417 UserDict.UserDict.__init__(self)
Guido van Rossumda4d6da1998-08-04 16:01:23[diff] [blame]418 data = self.data
Guido van Rossumda4d6da1998-08-04 16:01:23[diff] [blame]419 for k, v in environ.items():
Guido van Rossum965fdae2000-04-04 19:50:04[diff] [blame]420 data[k.upper()] = v
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]421 def __setitem__(self, key, item):
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]422 putenv(key, item)
Guido van Rossum965fdae2000-04-04 19:50:04[diff] [blame]423 self.data[key.upper()] = item
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]424 def __getitem__(self, key):
Guido van Rossum965fdae2000-04-04 19:50:04[diff] [blame]425 return self.data[key.upper()]
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]426 try:
427 unsetenv
428 except NameError:
429 def __delitem__(self, key):
430 del self.data[key.upper()]
431 else:
432 def __delitem__(self, key):
433 unsetenv(key)
434 del self.data[key.upper()]
Georg Brandl4a212682007-09-20 17:57:59[diff] [blame]435 def clear(self):
436 for key in self.data.keys():
437 unsetenv(key)
438 del self.data[key]
Georg Brandl1a94ec22007-10-24 21:40:38[diff] [blame]439 def pop(self, key, *args):
440 unsetenv(key)
Georg Brandldd1a8462007-10-26 18:30:41[diff] [blame]441 return self.data.pop(key.upper(), *args)
Guido van Rossumb46413f1999-05-03 15:23:24[diff] [blame]442 def has_key(self, key):
Raymond Hettinger54f02222002-06-01 14:18:47[diff] [blame]443 return key.upper() in self.data
444 def __contains__(self, key):
445 return key.upper() in self.data
Guido van Rossum965fdae2000-04-04 19:50:04[diff] [blame]446 def get(self, key, failobj=None):
447 return self.data.get(key.upper(), failobj)
Martin v. Löwis1d11de62005-01-29 13:29:23[diff] [blame]448 def update(self, dict=None, **kwargs):
449 if dict:
450 try:
Martin v. Löwis5510f652005-02-17 21:23:20[diff] [blame]451 keys = dict.keys()
Martin v. Löwis1d11de62005-01-29 13:29:23[diff] [blame]452 except AttributeError:
453 # List of (key, value)
Martin v. Löwis5510f652005-02-17 21:23:20[diff] [blame]454 for k, v in dict:
455 self[k] = v
456 else:
457 # got keys
458 # cannot use items(), since mappings
459 # may not have them.
460 for k in keys:
461 self[k] = dict[k]
Martin v. Löwis1d11de62005-01-29 13:29:23[diff] [blame]462 if kwargs:
463 self.update(kwargs)
Martin v. Löwisa066f462002-05-02 17:39:19[diff] [blame]464 def copy(self):
465 return dict(self)
Guido van Rossum3b8e20d1996-07-24 00:55:17[diff] [blame]466
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]467 else: # Where Env Var Names Can Be Mixed Case
Raymond Hettinger05212fc2002-09-07 04:48:03[diff] [blame]468 class _Environ(UserDict.IterableUserDict):
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]469 def __init__(self, environ):
470 UserDict.UserDict.__init__(self)
471 self.data = environ
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]472 def __setitem__(self, key, item):
473 putenv(key, item)
474 self.data[key] = item
Martin v. Löwis1d11de62005-01-29 13:29:23[diff] [blame]475 def update(self, dict=None, **kwargs):
476 if dict:
477 try:
Martin v. Löwis5510f652005-02-17 21:23:20[diff] [blame]478 keys = dict.keys()
Martin v. Löwis1d11de62005-01-29 13:29:23[diff] [blame]479 except AttributeError:
480 # List of (key, value)
Martin v. Löwis5510f652005-02-17 21:23:20[diff] [blame]481 for k, v in dict:
482 self[k] = v
483 else:
484 # got keys
485 # cannot use items(), since mappings
486 # may not have them.
487 for k in keys:
488 self[k] = dict[k]
Martin v. Löwis1d11de62005-01-29 13:29:23[diff] [blame]489 if kwargs:
490 self.update(kwargs)
Guido van Rossumc524d952001-10-19 01:31:59[diff] [blame]491 try:
492 unsetenv
493 except NameError:
494 pass
495 else:
496 def __delitem__(self, key):
497 unsetenv(key)
498 del self.data[key]
Georg Brandl4a212682007-09-20 17:57:59[diff] [blame]499 def clear(self):
500 for key in self.data.keys():
501 unsetenv(key)
502 del self.data[key]
Georg Brandl1a94ec22007-10-24 21:40:38[diff] [blame]503 def pop(self, key, *args):
504 unsetenv(key)
505 return self.data.pop(key, *args)
Martin v. Löwisa066f462002-05-02 17:39:19[diff] [blame]506 def copy(self):
507 return dict(self)
Tim Peters1633a2e2001-10-30 05:56:40[diff] [blame]508
Guido van Rossum61de0ac1997-12-05 21:24:30[diff] [blame]509
510 environ = _Environ(environ)
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]511
Jack Jansenb11ce9b2003-01-08 16:33:40[diff] [blame]512def getenv(key, default=None):
Tim Peters2c60f7a2003-01-29 03:49:43[diff] [blame]513 """Get an environment variable, return None if it doesn't exist.
514 The optional second argument can specify an alternate default."""
515 return environ.get(key, default)
Jack Jansenb11ce9b2003-01-08 16:33:40[diff] [blame]516__all__.append("getenv")
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]517
518def _exists(name):
Amaury Forgeot d'Arc03dcc732009-06-09 22:53:16[diff] [blame]519 return name in globals()
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]520
521# Supply spawn*() (probably only for Unix)
522if _exists("fork") and not _exists("spawnv") and _exists("execv"):
523
524 P_WAIT = 0
525 P_NOWAIT = P_NOWAITO = 1
526
527 # XXX Should we support P_DETACH? I suppose it could fork()**2
528 # and close the std I/O streams. Also, P_OVERLAY is the same
529 # as execv*()?
530
531 def _spawnvef(mode, file, args, env, func):
532 # Internal helper; func is the exec*() function to use
533 pid = fork()
534 if not pid:
535 # Child
536 try:
537 if env is None:
538 func(file, args)
539 else:
540 func(file, args, env)
541 except:
542 _exit(127)
543 else:
544 # Parent
545 if mode == P_NOWAIT:
546 return pid # Caller is responsible for waiting!
547 while 1:
548 wpid, sts = waitpid(pid, 0)
549 if WIFSTOPPED(sts):
550 continue
551 elif WIFSIGNALED(sts):
552 return -WTERMSIG(sts)
553 elif WIFEXITED(sts):
554 return WEXITSTATUS(sts)
555 else:
556 raise error, "Not stopped, signaled or exited???"
557
558 def spawnv(mode, file, args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]559 """spawnv(mode, file, args) -> integer
560
561Execute file with arguments from args in a subprocess.
562If mode == P_NOWAIT return the pid of the process.
563If mode == P_WAIT return the process's exit code if it exits normally;
Tim Peters2344fae2001-01-15 00:50:52[diff] [blame]564otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]565 return _spawnvef(mode, file, args, None, execv)
566
567 def spawnve(mode, file, args, env):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]568 """spawnve(mode, file, args, env) -> integer
569
570Execute file with arguments from args in a subprocess with the
571specified environment.
572If mode == P_NOWAIT return the pid of the process.
573If mode == P_WAIT return the process's exit code if it exits normally;
574otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]575 return _spawnvef(mode, file, args, env, execve)
576
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]577 # Note: spawnvp[e] is't currently supported on Windows
578
579 def spawnvp(mode, file, args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]580 """spawnvp(mode, file, args) -> integer
581
582Execute file (which is looked for along $PATH) with arguments from
583args in a subprocess.
584If mode == P_NOWAIT return the pid of the process.
585If mode == P_WAIT return the process's exit code if it exits normally;
586otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]587 return _spawnvef(mode, file, args, None, execvp)
588
589 def spawnvpe(mode, file, args, env):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]590 """spawnvpe(mode, file, args, env) -> integer
591
592Execute file (which is looked for along $PATH) with arguments from
593args in a subprocess with the supplied environment.
594If mode == P_NOWAIT return the pid of the process.
595If mode == P_WAIT return the process's exit code if it exits normally;
596otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]597 return _spawnvef(mode, file, args, env, execvpe)
598
599if _exists("spawnv"):
600 # These aren't supplied by the basic Windows code
601 # but can be easily implemented in Python
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]602
603 def spawnl(mode, file, *args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]604 """spawnl(mode, file, *args) -> integer
605
606Execute file with arguments from args in a subprocess.
607If mode == P_NOWAIT return the pid of the process.
608If mode == P_WAIT return the process's exit code if it exits normally;
609otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]610 return spawnv(mode, file, args)
611
612 def spawnle(mode, file, *args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]613 """spawnle(mode, file, *args, env) -> integer
614
615Execute file with arguments from args in a subprocess with the
616supplied environment.
617If mode == P_NOWAIT return the pid of the process.
618If mode == P_WAIT return the process's exit code if it exits normally;
619otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]620 env = args[-1]
621 return spawnve(mode, file, args[:-1], env)
622
Andrew MacIntyre69e18c92004-04-04 07:11:43[diff] [blame]623
624 __all__.extend(["spawnv", "spawnve", "spawnl", "spawnle",])
625
626
Guido van Rossumdd7cbbf1999-11-02 20:44:07[diff] [blame]627if _exists("spawnvp"):
628 # At the moment, Windows doesn't implement spawnvp[e],
629 # so it won't have spawnlp[e] either.
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]630 def spawnlp(mode, file, *args):
Neal Norwitzb7f68102003-07-02 02:49:33[diff] [blame]631 """spawnlp(mode, file, *args) -> integer
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]632
633Execute file (which is looked for along $PATH) with arguments from
634args in a subprocess with the supplied environment.
635If mode == P_NOWAIT return the pid of the process.
636If mode == P_WAIT return the process's exit code if it exits normally;
637otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]638 return spawnvp(mode, file, args)
639
640 def spawnlpe(mode, file, *args):
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]641 """spawnlpe(mode, file, *args, env) -> integer
642
643Execute file (which is looked for along $PATH) with arguments from
644args in a subprocess with the supplied environment.
645If mode == P_NOWAIT return the pid of the process.
646If mode == P_WAIT return the process's exit code if it exits normally;
647otherwise return -SIG, where SIG is the signal that killed it. """
Guido van Rossum5a2ca931999-11-02 13:27:32[diff] [blame]648 env = args[-1]
649 return spawnvpe(mode, file, args[:-1], env)
Guido van Rossume0cd2912000-04-21 18:35:36[diff] [blame]650
651
Andrew MacIntyre69e18c92004-04-04 07:11:43[diff] [blame]652 __all__.extend(["spawnvp", "spawnvpe", "spawnlp", "spawnlpe",])
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]653
654
Guido van Rossumd9a8e962000-09-19 03:04:52[diff] [blame]655# Supply popen2 etc. (for Unix)
656if _exists("fork"):
657 if not _exists("popen2"):
658 def popen2(cmd, mode="t", bufsize=-1):
Johannes Gijsbers9fc97892004-10-11 18:12:20[diff] [blame]659 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
660 may be a sequence, in which case arguments will be passed directly to
661 the program without shell intervention (as with os.spawnv()). If 'cmd'
662 is a string it will be passed to the shell (as with os.system()). If
663 'bufsize' is specified, it sets the buffer size for the I/O pipes. The
664 file objects (child_stdin, child_stdout) are returned."""
Neal Norwitz42dd86b2007-05-11 06:57:33[diff] [blame]665 import warnings
666 msg = "os.popen2 is deprecated. Use the subprocess module."
667 warnings.warn(msg, DeprecationWarning, stacklevel=2)
668
669 import subprocess
670 PIPE = subprocess.PIPE
Philip Jenvey8b902042009-09-29 19:10:15[diff] [blame]671 p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
672 bufsize=bufsize, stdin=PIPE, stdout=PIPE,
673 close_fds=True)
Neal Norwitz42dd86b2007-05-11 06:57:33[diff] [blame]674 return p.stdin, p.stdout
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]675 __all__.append("popen2")
Fred Drake31f182e2000-08-28 17:20:05[diff] [blame]676
Guido van Rossumd9a8e962000-09-19 03:04:52[diff] [blame]677 if not _exists("popen3"):
678 def popen3(cmd, mode="t", bufsize=-1):
Johannes Gijsbers9fc97892004-10-11 18:12:20[diff] [blame]679 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
680 may be a sequence, in which case arguments will be passed directly to
681 the program without shell intervention (as with os.spawnv()). If 'cmd'
682 is a string it will be passed to the shell (as with os.system()). If
683 'bufsize' is specified, it sets the buffer size for the I/O pipes. The
684 file objects (child_stdin, child_stdout, child_stderr) are returned."""
Neal Norwitz42dd86b2007-05-11 06:57:33[diff] [blame]685 import warnings
686 msg = "os.popen3 is deprecated. Use the subprocess module."
687 warnings.warn(msg, DeprecationWarning, stacklevel=2)
688
689 import subprocess
690 PIPE = subprocess.PIPE
Philip Jenvey8b902042009-09-29 19:10:15[diff] [blame]691 p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
692 bufsize=bufsize, stdin=PIPE, stdout=PIPE,
693 stderr=PIPE, close_fds=True)
Neal Norwitz42dd86b2007-05-11 06:57:33[diff] [blame]694 return p.stdin, p.stdout, p.stderr
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]695 __all__.append("popen3")
Fred Drake20af3172000-09-28 19:10:56[diff] [blame]696
697 if not _exists("popen4"):
698 def popen4(cmd, mode="t", bufsize=-1):
Johannes Gijsbers9fc97892004-10-11 18:12:20[diff] [blame]699 """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
700 may be a sequence, in which case arguments will be passed directly to
701 the program without shell intervention (as with os.spawnv()). If 'cmd'
702 is a string it will be passed to the shell (as with os.system()). If
703 'bufsize' is specified, it sets the buffer size for the I/O pipes. The
704 file objects (child_stdin, child_stdout_stderr) are returned."""
Neal Norwitz42dd86b2007-05-11 06:57:33[diff] [blame]705 import warnings
706 msg = "os.popen4 is deprecated. Use the subprocess module."
707 warnings.warn(msg, DeprecationWarning, stacklevel=2)
708
709 import subprocess
710 PIPE = subprocess.PIPE
Philip Jenvey8b902042009-09-29 19:10:15[diff] [blame]711 p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
712 bufsize=bufsize, stdin=PIPE, stdout=PIPE,
Neal Norwitz42dd86b2007-05-11 06:57:33[diff] [blame]713 stderr=subprocess.STDOUT, close_fds=True)
714 return p.stdin, p.stdout
Skip Montanaro269b83b2001-02-06 01:07:02[diff] [blame]715 __all__.append("popen4")
Michael W. Hudson0e025302002-03-06 17:11:18[diff] [blame]716
Georg Brandldffbf5f2008-05-20 07:49:57[diff] [blame]717import copy_reg as _copy_reg
Michael W. Hudson0e025302002-03-06 17:11:18[diff] [blame]718
719def _make_stat_result(tup, dict):
720 return stat_result(tup, dict)
721
722def _pickle_stat_result(sr):
723 (type, args) = sr.__reduce__()
724 return (_make_stat_result, args)
725
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]726try:
727 _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
728except NameError: # stat_result may not exist
729 pass
Michael W. Hudson0e025302002-03-06 17:11:18[diff] [blame]730
731def _make_statvfs_result(tup, dict):
732 return statvfs_result(tup, dict)
733
734def _pickle_statvfs_result(sr):
735 (type, args) = sr.__reduce__()
736 return (_make_statvfs_result, args)
737
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]738try:
739 _copy_reg.pickle(statvfs_result, _pickle_statvfs_result,
740 _make_statvfs_result)
Michael W. Hudsone5363b72002-03-15 10:21:59[diff] [blame]741except NameError: # statvfs_result may not exist
Michael W. Hudsonce00b732002-03-15 10:18:58[diff] [blame]742 pass