]>
Commit | Line | Data |
---|---|---|
a579c870 JB |
1 | """ path.py - An object representing a path to a file or directory. |
2 | ||
3 | Example: | |
4 | ||
5 | from path import path | |
6 | d = path('/home/guido/bin') | |
7 | for f in d.files('*.py'): | |
8 | f.chmod(0755) | |
9 | ||
10 | This module requires Python 2.2 or later. | |
11 | ||
12 | ||
13 | URL: http://www.jorendorff.com/articles/python/path | |
14 | Author: Jason Orendorff <jason@jorendorff.com> (and others - see the url!) | |
15 | Date: 7 Mar 2004 | |
16 | """ | |
17 | ||
18 | ||
19 | # TODO | |
20 | # - Bug in write_text(). It doesn't support Universal newline mode. | |
21 | # - Better error message in listdir() when self isn't a | |
22 | # directory. (On Windows, the error message really sucks.) | |
23 | # - Make sure everything has a good docstring. | |
24 | # - Add methods for regex find and replace. | |
25 | # - guess_content_type() method? | |
26 | # - Perhaps support arguments to touch(). | |
27 | # - Could add split() and join() methods that generate warnings. | |
28 | # - Note: __add__() technically has a bug, I think, where | |
29 | # it doesn't play nice with other types that implement | |
30 | # __radd__(). Test this. | |
31 | ||
32 | from __future__ import generators | |
33 | ||
34 | import sys, os, fnmatch, glob, shutil, codecs | |
35 | ||
36 | __version__ = '2.0.4' | |
37 | __all__ = ['path'] | |
38 | ||
39 | # Pre-2.3 support. Are unicode filenames supported? | |
40 | _base = str | |
41 | try: | |
42 | if os.path.supports_unicode_filenames: | |
43 | _base = unicode | |
44 | except AttributeError: | |
45 | pass | |
46 | ||
47 | # Pre-2.3 workaround for basestring. | |
48 | try: | |
49 | basestring | |
50 | except NameError: | |
51 | basestring = (str, unicode) | |
52 | ||
53 | # Universal newline support | |
54 | _textmode = 'r' | |
55 | if hasattr(file, 'newlines'): | |
56 | _textmode = 'U' | |
57 | ||
58 | ||
59 | class path(_base): | |
60 | """ Represents a filesystem path. | |
61 | ||
62 | For documentation on individual methods, consult their | |
63 | counterparts in os.path. | |
64 | """ | |
65 | ||
66 | # --- Special Python methods. | |
67 | ||
68 | def __repr__(self): | |
69 | return 'path(%s)' % _base.__repr__(self) | |
70 | ||
71 | # Adding a path and a string yields a path. | |
72 | def __add__(self, more): | |
73 | return path(_base(self) + more) | |
74 | ||
75 | def __radd__(self, other): | |
76 | return path(other + _base(self)) | |
77 | ||
78 | # The / operator joins paths. | |
79 | def __div__(self, rel): | |
80 | """ fp.__div__(rel) == fp / rel == fp.joinpath(rel) | |
81 | ||
82 | Join two path components, adding a separator character if | |
83 | needed. | |
84 | """ | |
85 | return path(os.path.join(self, rel)) | |
86 | ||
87 | # Make the / operator work even when true division is enabled. | |
88 | __truediv__ = __div__ | |
89 | ||
90 | def getcwd(): | |
91 | """ Return the current working directory as a path object. """ | |
92 | return path(os.getcwd()) | |
93 | getcwd = staticmethod(getcwd) | |
94 | ||
95 | ||
96 | # --- Operations on path strings. | |
97 | ||
98 | def abspath(self): return path(os.path.abspath(self)) | |
99 | def normcase(self): return path(os.path.normcase(self)) | |
100 | def normpath(self): return path(os.path.normpath(self)) | |
101 | def realpath(self): return path(os.path.realpath(self)) | |
102 | def expanduser(self): return path(os.path.expanduser(self)) | |
103 | def expandvars(self): return path(os.path.expandvars(self)) | |
104 | def dirname(self): return path(os.path.dirname(self)) | |
105 | basename = os.path.basename | |
106 | ||
107 | def expand(self): | |
108 | """ Clean up a filename by calling expandvars(), | |
109 | expanduser(), and normpath() on it. | |
110 | ||
111 | This is commonly everything needed to clean up a filename | |
112 | read from a configuration file, for example. | |
113 | """ | |
114 | return self.expandvars().expanduser().normpath() | |
115 | ||
116 | def _get_namebase(self): | |
117 | base, ext = os.path.splitext(self.name) | |
118 | return base | |
119 | ||
120 | def _get_ext(self): | |
121 | f, ext = os.path.splitext(_base(self)) | |
122 | return ext | |
123 | ||
124 | def _get_drive(self): | |
125 | drive, r = os.path.splitdrive(self) | |
126 | return path(drive) | |
127 | ||
128 | parent = property( | |
129 | dirname, None, None, | |
130 | """ This path's parent directory, as a new path object. | |
131 | ||
132 | For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib') | |
133 | """) | |
134 | ||
135 | name = property( | |
136 | basename, None, None, | |
137 | """ The name of this file or directory without the full path. | |
138 | ||
139 | For example, path('/usr/local/lib/libpython.so').name == 'libpython.so' | |
140 | """) | |
141 | ||
142 | namebase = property( | |
143 | _get_namebase, None, None, | |
144 | """ The same as path.name, but with one file extension stripped off. | |
145 | ||
146 | For example, path('/home/guido/python.tar.gz').name == 'python.tar.gz', | |
147 | but path('/home/guido/python.tar.gz').namebase == 'python.tar' | |
148 | """) | |
149 | ||
150 | ext = property( | |
151 | _get_ext, None, None, | |
152 | """ The file extension, for example '.py'. """) | |
153 | ||
154 | drive = property( | |
155 | _get_drive, None, None, | |
156 | """ The drive specifier, for example 'C:'. | |
157 | This is always empty on systems that don't use drive specifiers. | |
158 | """) | |
159 | ||
160 | def splitpath(self): | |
161 | """ p.splitpath() -> Return (p.parent, p.name). """ | |
162 | parent, child = os.path.split(self) | |
163 | return path(parent), child | |
164 | ||
165 | def splitdrive(self): | |
166 | """ p.splitdrive() -> Return (p.drive, <the rest of p>). | |
167 | ||
168 | Split the drive specifier from this path. If there is | |
169 | no drive specifier, p.drive is empty, so the return value | |
170 | is simply (path(''), p). This is always the case on Unix. | |
171 | """ | |
172 | drive, rel = os.path.splitdrive(self) | |
173 | return path(drive), rel | |
174 | ||
175 | def splitext(self): | |
176 | """ p.splitext() -> Return (p.stripext(), p.ext). | |
177 | ||
178 | Split the filename extension from this path and return | |
179 | the two parts. Either part may be empty. | |
180 | ||
181 | The extension is everything from '.' to the end of the | |
182 | last path segment. This has the property that if | |
183 | (a, b) == p.splitext(), then a + b == p. | |
184 | """ | |
185 | filename, ext = os.path.splitext(self) | |
186 | return path(filename), ext | |
187 | ||
188 | def stripext(self): | |
189 | """ p.stripext() -> Remove one file extension from the path. | |
190 | ||
191 | For example, path('/home/guido/python.tar.gz').stripext() | |
192 | returns path('/home/guido/python.tar'). | |
193 | """ | |
194 | return self.splitext()[0] | |
195 | ||
196 | if hasattr(os.path, 'splitunc'): | |
197 | def splitunc(self): | |
198 | unc, rest = os.path.splitunc(self) | |
199 | return path(unc), rest | |
200 | ||
201 | def _get_uncshare(self): | |
202 | unc, r = os.path.splitunc(self) | |
203 | return path(unc) | |
204 | ||
205 | uncshare = property( | |
206 | _get_uncshare, None, None, | |
207 | """ The UNC mount point for this path. | |
208 | This is empty for paths on local drives. """) | |
209 | ||
210 | def joinpath(self, *args): | |
211 | """ Join two or more path components, adding a separator | |
212 | character (os.sep) if needed. Returns a new path | |
213 | object. | |
214 | """ | |
215 | return path(os.path.join(self, *args)) | |
216 | ||
217 | def splitall(self): | |
218 | """ Return a list of the path components in this path. | |
219 | ||
220 | The first item in the list will be a path. Its value will be | |
221 | either os.curdir, os.pardir, empty, or the root directory of | |
222 | this path (for example, '/' or 'C:\\'). The other items in | |
223 | the list will be strings. | |
224 | ||
225 | path.path.joinpath(*result) will yield the original path. | |
226 | """ | |
227 | parts = [] | |
228 | loc = self | |
229 | while loc != os.curdir and loc != os.pardir: | |
230 | prev = loc | |
231 | loc, child = prev.splitpath() | |
232 | if loc == prev: | |
233 | break | |
234 | parts.append(child) | |
235 | parts.append(loc) | |
236 | parts.reverse() | |
237 | return parts | |
238 | ||
239 | def relpath(self): | |
240 | """ Return this path as a relative path, | |
241 | based from the current working directory. | |
242 | """ | |
243 | cwd = path(os.getcwd()) | |
244 | return cwd.relpathto(self) | |
245 | ||
246 | def relpathto(self, dest): | |
247 | """ Return a relative path from self to dest. | |
248 | ||
249 | If there is no relative path from self to dest, for example if | |
250 | they reside on different drives in Windows, then this returns | |
251 | dest.abspath(). | |
252 | """ | |
253 | origin = self.abspath() | |
254 | dest = path(dest).abspath() | |
255 | ||
256 | orig_list = origin.normcase().splitall() | |
257 | # Don't normcase dest! We want to preserve the case. | |
258 | dest_list = dest.splitall() | |
259 | ||
260 | if orig_list[0] != os.path.normcase(dest_list[0]): | |
261 | # Can't get here from there. | |
262 | return dest | |
263 | ||
264 | # Find the location where the two paths start to differ. | |
265 | i = 0 | |
266 | for start_seg, dest_seg in zip(orig_list, dest_list): | |
267 | if start_seg != os.path.normcase(dest_seg): | |
268 | break | |
269 | i += 1 | |
270 | ||
271 | # Now i is the point where the two paths diverge. | |
272 | # Need a certain number of "os.pardir"s to work up | |
273 | # from the origin to the point of divergence. | |
274 | segments = [os.pardir] * (len(orig_list) - i) | |
275 | # Need to add the diverging part of dest_list. | |
276 | segments += dest_list[i:] | |
277 | if len(segments) == 0: | |
278 | # If they happen to be identical, use os.curdir. | |
279 | return path(os.curdir) | |
280 | else: | |
281 | return path(os.path.join(*segments)) | |
282 | ||
283 | ||
284 | # --- Listing, searching, walking, and matching | |
285 | ||
286 | def listdir(self, pattern=None): | |
287 | """ D.listdir() -> List of items in this directory. | |
288 | ||
289 | Use D.files() or D.dirs() instead if you want a listing | |
290 | of just files or just subdirectories. | |
291 | ||
292 | The elements of the list are path objects. | |
293 | ||
294 | With the optional 'pattern' argument, this only lists | |
295 | items whose names match the given pattern. | |
296 | """ | |
297 | names = os.listdir(self) | |
298 | if pattern is not None: | |
299 | names = fnmatch.filter(names, pattern) | |
300 | return [self / child for child in names] | |
301 | ||
302 | def dirs(self, pattern=None): | |
303 | """ D.dirs() -> List of this directory's subdirectories. | |
304 | ||
305 | The elements of the list are path objects. | |
306 | This does not walk recursively into subdirectories | |
307 | (but see path.walkdirs). | |
308 | ||
309 | With the optional 'pattern' argument, this only lists | |
310 | directories whose names match the given pattern. For | |
311 | example, d.dirs('build-*'). | |
312 | """ | |
313 | return [p for p in self.listdir(pattern) if p.isdir()] | |
314 | ||
315 | def files(self, pattern=None): | |
316 | """ D.files() -> List of the files in this directory. | |
317 | ||
318 | The elements of the list are path objects. | |
319 | This does not walk into subdirectories (see path.walkfiles). | |
320 | ||
321 | With the optional 'pattern' argument, this only lists files | |
322 | whose names match the given pattern. For example, | |
323 | d.files('*.pyc'). | |
324 | """ | |
325 | ||
326 | return [p for p in self.listdir(pattern) if p.isfile()] | |
327 | ||
328 | def walk(self, pattern=None): | |
329 | """ D.walk() -> iterator over files and subdirs, recursively. | |
330 | ||
331 | The iterator yields path objects naming each child item of | |
332 | this directory and its descendants. This requires that | |
333 | D.isdir(). | |
334 | ||
335 | This performs a depth-first traversal of the directory tree. | |
336 | Each directory is returned just before all its children. | |
337 | """ | |
338 | for child in self.listdir(): | |
339 | if pattern is None or child.fnmatch(pattern): | |
340 | yield child | |
341 | if child.isdir(): | |
342 | for item in child.walk(pattern): | |
343 | yield item | |
344 | ||
345 | def walkdirs(self, pattern=None): | |
346 | """ D.walkdirs() -> iterator over subdirs, recursively. | |
347 | ||
348 | With the optional 'pattern' argument, this yields only | |
349 | directories whose names match the given pattern. For | |
350 | example, mydir.walkdirs('*test') yields only directories | |
351 | with names ending in 'test'. | |
352 | """ | |
353 | for child in self.dirs(): | |
354 | if pattern is None or child.fnmatch(pattern): | |
355 | yield child | |
356 | for subsubdir in child.walkdirs(pattern): | |
357 | yield subsubdir | |
358 | ||
359 | def walkfiles(self, pattern=None): | |
360 | """ D.walkfiles() -> iterator over files in D, recursively. | |
361 | ||
362 | The optional argument, pattern, limits the results to files | |
363 | with names that match the pattern. For example, | |
364 | mydir.walkfiles('*.tmp') yields only files with the .tmp | |
365 | extension. | |
366 | """ | |
367 | for child in self.listdir(): | |
368 | if child.isfile(): | |
369 | if pattern is None or child.fnmatch(pattern): | |
370 | yield child | |
371 | elif child.isdir(): | |
372 | for f in child.walkfiles(pattern): | |
373 | yield f | |
374 | ||
375 | def fnmatch(self, pattern): | |
376 | """ Return True if self.name matches the given pattern. | |
377 | ||
378 | pattern - A filename pattern with wildcards, | |
379 | for example '*.py'. | |
380 | """ | |
381 | return fnmatch.fnmatch(self.name, pattern) | |
382 | ||
383 | def glob(self, pattern): | |
384 | """ Return a list of path objects that match the pattern. | |
385 | ||
386 | pattern - a path relative to this directory, with wildcards. | |
387 | ||
388 | For example, path('/users').glob('*/bin/*') returns a list | |
389 | of all the files users have in their bin directories. | |
390 | """ | |
391 | return map(path, glob.glob(_base(self / pattern))) | |
392 | ||
393 | ||
394 | # --- Reading or writing an entire file at once. | |
395 | ||
396 | def open(self, mode='r'): | |
397 | """ Open this file. Return a file object. """ | |
398 | return file(self, mode) | |
399 | ||
400 | def bytes(self): | |
401 | """ Open this file, read all bytes, return them as a string. """ | |
402 | f = self.open('rb') | |
403 | try: | |
404 | return f.read() | |
405 | finally: | |
406 | f.close() | |
407 | ||
408 | def write_bytes(self, bytes, append=False): | |
409 | """ Open this file and write the given bytes to it. | |
410 | ||
411 | Default behavior is to overwrite any existing file. | |
412 | Call this with write_bytes(bytes, append=True) to append instead. | |
413 | """ | |
414 | if append: | |
415 | mode = 'ab' | |
416 | else: | |
417 | mode = 'wb' | |
418 | f = self.open(mode) | |
419 | try: | |
420 | f.write(bytes) | |
421 | finally: | |
422 | f.close() | |
423 | ||
424 | def text(self, encoding=None, errors='strict'): | |
425 | """ Open this file, read it in, return the content as a string. | |
426 | ||
427 | This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r' | |
428 | are automatically translated to '\n'. | |
429 | ||
430 | Optional arguments: | |
431 | ||
432 | encoding - The Unicode encoding (or character set) of | |
433 | the file. If present, the content of the file is | |
434 | decoded and returned as a unicode object; otherwise | |
435 | it is returned as an 8-bit str. | |
436 | errors - How to handle Unicode errors; see help(str.decode) | |
437 | for the options. Default is 'strict'. | |
438 | """ | |
439 | if encoding is None: | |
440 | # 8-bit | |
441 | f = self.open(_textmode) | |
442 | try: | |
443 | return f.read() | |
444 | finally: | |
445 | f.close() | |
446 | else: | |
447 | # Unicode | |
448 | f = codecs.open(self, 'r', encoding, errors) | |
449 | # (Note - Can't use 'U' mode here, since codecs.open | |
450 | # doesn't support 'U' mode, even in Python 2.3.) | |
451 | try: | |
452 | t = f.read() | |
453 | finally: | |
454 | f.close() | |
455 | return (t.replace(u'\r\n', u'\n') | |
456 | .replace(u'\r\x85', u'\n') | |
457 | .replace(u'\r', u'\n') | |
458 | .replace(u'\x85', u'\n') | |
459 | .replace(u'\u2028', u'\n')) | |
460 | ||
461 | def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False): | |
462 | """ Write the given text to this file. | |
463 | ||
464 | The default behavior is to overwrite any existing file; | |
465 | to append instead, use the 'append=True' keyword argument. | |
466 | ||
467 | There are two differences between path.write_text() and | |
468 | path.write_bytes(): newline handling and Unicode handling. | |
469 | See below. | |
470 | ||
471 | Parameters: | |
472 | ||
473 | - text - str/unicode - The text to be written. | |
474 | ||
475 | - encoding - str - The Unicode encoding that will be used. | |
476 | This is ignored if 'text' isn't a Unicode string. | |
477 | ||
478 | - errors - str - How to handle Unicode encoding errors. | |
479 | Default is 'strict'. See help(unicode.encode) for the | |
480 | options. This is ignored if 'text' isn't a Unicode | |
481 | string. | |
482 | ||
483 | - linesep - keyword argument - str/unicode - The sequence of | |
484 | characters to be used to mark end-of-line. The default is | |
485 | os.linesep. You can also specify None; this means to | |
486 | leave all newlines as they are in 'text'. | |
487 | ||
488 | - append - keyword argument - bool - Specifies what to do if | |
489 | the file already exists (True: append to the end of it; | |
490 | False: overwrite it.) The default is False. | |
491 | ||
492 | ||
493 | --- Newline handling. | |
494 | ||
495 | write_text() converts all standard end-of-line sequences | |
496 | ('\n', '\r', and '\r\n') to your platform's default end-of-line | |
497 | sequence (see os.linesep; on Windows, for example, the | |
498 | end-of-line marker is '\r\n'). | |
499 | ||
500 | If you don't like your platform's default, you can override it | |
501 | using the 'linesep=' keyword argument. If you specifically want | |
502 | write_text() to preserve the newlines as-is, use 'linesep=None'. | |
503 | ||
504 | This applies to Unicode text the same as to 8-bit text, except | |
505 | there are three additional standard Unicode end-of-line sequences: | |
506 | u'\x85', u'\r\x85', and u'\u2028'. | |
507 | ||
508 | (This is slightly different from when you open a file for | |
509 | writing with fopen(filename, "w") in C or file(filename, 'w') | |
510 | in Python.) | |
511 | ||
512 | ||
513 | --- Unicode | |
514 | ||
515 | If 'text' isn't Unicode, then apart from newline handling, the | |
516 | bytes are written verbatim to the file. The 'encoding' and | |
517 | 'errors' arguments are not used and must be omitted. | |
518 | ||
519 | If 'text' is Unicode, it is first converted to bytes using the | |
520 | specified 'encoding' (or the default encoding if 'encoding' | |
521 | isn't specified). The 'errors' argument applies only to this | |
522 | conversion. | |
523 | ||
524 | """ | |
525 | if isinstance(text, unicode): | |
526 | if linesep is not None: | |
527 | # Convert all standard end-of-line sequences to | |
528 | # ordinary newline characters. | |
529 | text = (text.replace(u'\r\n', u'\n') | |
530 | .replace(u'\r\x85', u'\n') | |
531 | .replace(u'\r', u'\n') | |
532 | .replace(u'\x85', u'\n') | |
533 | .replace(u'\u2028', u'\n')) | |
534 | text = text.replace(u'\n', linesep) | |
535 | if encoding is None: | |
536 | encoding = sys.getdefaultencoding() | |
537 | bytes = text.encode(encoding, errors) | |
538 | else: | |
539 | # It is an error to specify an encoding if 'text' is | |
540 | # an 8-bit string. | |
541 | assert encoding is None | |
542 | ||
543 | if linesep is not None: | |
544 | text = (text.replace('\r\n', '\n') | |
545 | .replace('\r', '\n')) | |
546 | bytes = text.replace('\n', linesep) | |
547 | ||
548 | self.write_bytes(bytes, append) | |
549 | ||
550 | def lines(self, encoding=None, errors='strict', retain=True): | |
551 | """ Open this file, read all lines, return them in a list. | |
552 | ||
553 | Optional arguments: | |
554 | encoding - The Unicode encoding (or character set) of | |
555 | the file. The default is None, meaning the content | |
556 | of the file is read as 8-bit characters and returned | |
557 | as a list of (non-Unicode) str objects. | |
558 | errors - How to handle Unicode errors; see help(str.decode) | |
559 | for the options. Default is 'strict' | |
560 | retain - If true, retain newline characters; but all newline | |
561 | character combinations ('\r', '\n', '\r\n') are | |
562 | translated to '\n'. If false, newline characters are | |
563 | stripped off. Default is True. | |
564 | ||
565 | This uses 'U' mode in Python 2.3 and later. | |
566 | """ | |
567 | if encoding is None and retain: | |
568 | f = self.open(_textmode) | |
569 | try: | |
570 | return f.readlines() | |
571 | finally: | |
572 | f.close() | |
573 | else: | |
574 | return self.text(encoding, errors).splitlines(retain) | |
575 | ||
576 | def write_lines(self, lines, encoding=None, errors='strict', | |
577 | linesep=os.linesep, append=False): | |
578 | """ Write the given lines of text to this file. | |
579 | ||
580 | By default this overwrites any existing file at this path. | |
581 | ||
582 | This puts a platform-specific newline sequence on every line. | |
583 | See 'linesep' below. | |
584 | ||
585 | lines - A list of strings. | |
586 | ||
587 | encoding - A Unicode encoding to use. This applies only if | |
588 | 'lines' contains any Unicode strings. | |
589 | ||
590 | errors - How to handle errors in Unicode encoding. This | |
591 | also applies only to Unicode strings. | |
592 | ||
593 | linesep - The desired line-ending. This line-ending is | |
594 | applied to every line. If a line already has any | |
595 | standard line ending ('\r', '\n', '\r\n', u'\x85', | |
596 | u'\r\x85', u'\u2028'), that will be stripped off and | |
597 | this will be used instead. The default is os.linesep, | |
598 | which is platform-dependent ('\r\n' on Windows, '\n' on | |
599 | Unix, etc.) Specify None to write the lines as-is, | |
600 | like file.writelines(). | |
601 | ||
602 | Use the keyword argument append=True to append lines to the | |
603 | file. The default is to overwrite the file. Warning: | |
604 | When you use this with Unicode data, if the encoding of the | |
605 | existing data in the file is different from the encoding | |
606 | you specify with the encoding= parameter, the result is | |
607 | mixed-encoding data, which can really confuse someone trying | |
608 | to read the file later. | |
609 | """ | |
610 | if append: | |
611 | mode = 'ab' | |
612 | else: | |
613 | mode = 'wb' | |
614 | f = self.open(mode) | |
615 | try: | |
616 | for line in lines: | |
617 | isUnicode = isinstance(line, unicode) | |
618 | if linesep is not None: | |
619 | # Strip off any existing line-end and add the | |
620 | # specified linesep string. | |
621 | if isUnicode: | |
622 | if line[-2:] in (u'\r\n', u'\x0d\x85'): | |
623 | line = line[:-2] | |
624 | elif line[-1:] in (u'\r', u'\n', | |
625 | u'\x85', u'\u2028'): | |
626 | line = line[:-1] | |
627 | else: | |
628 | if line[-2:] == '\r\n': | |
629 | line = line[:-2] | |
630 | elif line[-1:] in ('\r', '\n'): | |
631 | line = line[:-1] | |
632 | line += linesep | |
633 | if isUnicode: | |
634 | if encoding is None: | |
635 | encoding = sys.getdefaultencoding() | |
636 | line = line.encode(encoding, errors) | |
637 | f.write(line) | |
638 | finally: | |
639 | f.close() | |
640 | ||
641 | ||
642 | # --- Methods for querying the filesystem. | |
643 | ||
644 | exists = os.path.exists | |
645 | isabs = os.path.isabs | |
646 | isdir = os.path.isdir | |
647 | isfile = os.path.isfile | |
648 | islink = os.path.islink | |
649 | ismount = os.path.ismount | |
650 | ||
651 | if hasattr(os.path, 'samefile'): | |
652 | samefile = os.path.samefile | |
653 | ||
654 | getatime = os.path.getatime | |
655 | atime = property( | |
656 | getatime, None, None, | |
657 | """ Last access time of the file. """) | |
658 | ||
659 | getmtime = os.path.getmtime | |
660 | mtime = property( | |
661 | getmtime, None, None, | |
662 | """ Last-modified time of the file. """) | |
663 | ||
664 | if hasattr(os.path, 'getctime'): | |
665 | getctime = os.path.getctime | |
666 | ctime = property( | |
667 | getctime, None, None, | |
668 | """ Creation time of the file. """) | |
669 | ||
670 | getsize = os.path.getsize | |
671 | size = property( | |
672 | getsize, None, None, | |
673 | """ Size of the file, in bytes. """) | |
674 | ||
675 | if hasattr(os, 'access'): | |
676 | def access(self, mode): | |
677 | """ Return true if current user has access to this path. | |
678 | ||
679 | mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK | |
680 | """ | |
681 | return os.access(self, mode) | |
682 | ||
683 | def stat(self): | |
684 | """ Perform a stat() system call on this path. """ | |
685 | return os.stat(self) | |
686 | ||
687 | def lstat(self): | |
688 | """ Like path.stat(), but do not follow symbolic links. """ | |
689 | return os.lstat(self) | |
690 | ||
691 | if hasattr(os, 'statvfs'): | |
692 | def statvfs(self): | |
693 | """ Perform a statvfs() system call on this path. """ | |
694 | return os.statvfs(self) | |
695 | ||
696 | if hasattr(os, 'pathconf'): | |
697 | def pathconf(self, name): | |
698 | return os.pathconf(self, name) | |
699 | ||
700 | ||
701 | # --- Modifying operations on files and directories | |
702 | ||
703 | def utime(self, times): | |
704 | """ Set the access and modified times of this file. """ | |
705 | os.utime(self, times) | |
706 | ||
707 | def chmod(self, mode): | |
708 | os.chmod(self, mode) | |
709 | ||
710 | if hasattr(os, 'chown'): | |
711 | def chown(self, uid, gid): | |
712 | os.chown(self, uid, gid) | |
713 | ||
714 | def rename(self, new): | |
715 | os.rename(self, new) | |
716 | ||
717 | def renames(self, new): | |
718 | os.renames(self, new) | |
719 | ||
720 | ||
721 | # --- Create/delete operations on directories | |
722 | ||
723 | def mkdir(self, mode=0777): | |
724 | os.mkdir(self, mode) | |
725 | ||
726 | def makedirs(self, mode=0777): | |
727 | os.makedirs(self, mode) | |
728 | ||
729 | def rmdir(self): | |
730 | os.rmdir(self) | |
731 | ||
732 | def removedirs(self): | |
733 | os.removedirs(self) | |
734 | ||
735 | ||
736 | # --- Modifying operations on files | |
737 | ||
738 | def touch(self): | |
739 | """ Set the access/modified times of this file to the current time. | |
740 | Create the file if it does not exist. | |
741 | """ | |
742 | fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666) | |
743 | os.close(fd) | |
744 | os.utime(self, None) | |
745 | ||
746 | def remove(self): | |
747 | os.remove(self) | |
748 | ||
749 | def unlink(self): | |
750 | os.unlink(self) | |
751 | ||
752 | ||
753 | # --- Links | |
754 | ||
755 | if hasattr(os, 'link'): | |
756 | def link(self, newpath): | |
757 | """ Create a hard link at 'newpath', pointing to this file. """ | |
758 | os.link(self, newpath) | |
759 | ||
760 | if hasattr(os, 'symlink'): | |
761 | def symlink(self, newlink): | |
762 | """ Create a symbolic link at 'newlink', pointing here. """ | |
763 | os.symlink(self, newlink) | |
764 | ||
765 | if hasattr(os, 'readlink'): | |
766 | def readlink(self): | |
767 | """ Return the path to which this symbolic link points. | |
768 | ||
769 | The result may be an absolute or a relative path. | |
770 | """ | |
771 | return path(os.readlink(self)) | |
772 | ||
773 | def readlinkabs(self): | |
774 | """ Return the path to which this symbolic link points. | |
775 | ||
776 | The result is always an absolute path. | |
777 | """ | |
778 | p = self.readlink() | |
779 | if p.isabs(): | |
780 | return p | |
781 | else: | |
782 | return (self.parent / p).abspath() | |
783 | ||
784 | ||
785 | # --- High-level functions from shutil | |
786 | ||
787 | copyfile = shutil.copyfile | |
788 | copymode = shutil.copymode | |
789 | copystat = shutil.copystat | |
790 | copy = shutil.copy | |
791 | copy2 = shutil.copy2 | |
792 | copytree = shutil.copytree | |
793 | if hasattr(shutil, 'move'): | |
794 | move = shutil.move | |
795 | rmtree = shutil.rmtree | |
796 | ||
797 | ||
798 | # --- Special stuff from os | |
799 | ||
800 | if hasattr(os, 'chroot'): | |
801 | def chroot(self): | |
802 | os.chroot(self) | |
803 | ||
804 | if hasattr(os, 'startfile'): | |
805 | def startfile(self): | |
806 | os.startfile(self) | |
807 |