Show More
This diff has been collapsed as it changes many lines, (807 lines changed) Show them Hide them | |||
@@ -0,0 +1,807 b'' | |||
|
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 |
@@ -1,66 +1,66 b'' | |||
|
1 | 1 | # -*- coding: utf-8 -*- |
|
2 | 2 | """ |
|
3 | 3 | IPython -- An enhanced Interactive Python |
|
4 | 4 | |
|
5 | 5 | One of Python's nicest features is its interactive interpreter. This allows |
|
6 | 6 | very fast testing of ideas without the overhead of creating test files as is |
|
7 | 7 | typical in most programming languages. However, the interpreter supplied with |
|
8 | 8 | the standard Python distribution is fairly primitive (and IDLE isn't really |
|
9 | 9 | much better). |
|
10 | 10 | |
|
11 | 11 | IPython tries to: |
|
12 | 12 | |
|
13 | 13 | i - provide an efficient environment for interactive work in Python |
|
14 | 14 | programming. It tries to address what we see as shortcomings of the standard |
|
15 | 15 | Python prompt, and adds many features to make interactive work much more |
|
16 | 16 | efficient. |
|
17 | 17 | |
|
18 | 18 | ii - offer a flexible framework so that it can be used as the base |
|
19 | 19 | environment for other projects and problems where Python can be the |
|
20 | 20 | underlying language. Specifically scientific environments like Mathematica, |
|
21 | 21 | IDL and Mathcad inspired its design, but similar ideas can be useful in many |
|
22 | 22 | fields. Python is a fabulous language for implementing this kind of system |
|
23 | 23 | (due to its dynamic and introspective features), and with suitable libraries |
|
24 | 24 | entire systems could be built leveraging Python's power. |
|
25 | 25 | |
|
26 | 26 | iii - serve as an embeddable, ready to go interpreter for your own programs. |
|
27 | 27 | |
|
28 | 28 | IPython requires Python 2.2 or newer. |
|
29 | 29 | |
|
30 |
$Id: __init__.py 10 |
|
|
30 | $Id: __init__.py 1025 2006-01-16 20:22:21Z vivainio $""" | |
|
31 | 31 | |
|
32 | 32 | #***************************************************************************** |
|
33 | 33 | # Copyright (C) 2001-2004 Fernando Perez. <fperez@colorado.edu> |
|
34 | 34 | # |
|
35 | 35 | # Distributed under the terms of the BSD License. The full license is in |
|
36 | 36 | # the file COPYING, distributed as part of this software. |
|
37 | 37 | #***************************************************************************** |
|
38 | 38 | |
|
39 | 39 | # Enforce proper version requirements |
|
40 | 40 | import sys |
|
41 | 41 | if sys.version[0:3] < '2.3': |
|
42 | 42 | raise ImportError, 'Python Version 2.3 or above is required.' |
|
43 | 43 | |
|
44 | 44 | # Define what gets imported with a 'from IPython import *' |
|
45 | 45 | __all__ = ['deep_reload','genutils','ipstruct','ultraTB','DPyGetOpt', |
|
46 | 46 | 'Itpl','hooks','ConfigLoader','OutputTrap','Release','Shell', |
|
47 | 47 | 'platutils','platutils_win32','platutils_posix','platutils_dummy', |
|
48 | 'ipapi'] | |
|
48 | 'ipapi','path'] | |
|
49 | 49 | |
|
50 | 50 | # Load __all__ in IPython namespace so that a simple 'import IPython' gives |
|
51 | 51 | # access to them via IPython.<name> |
|
52 | 52 | glob,loc = globals(),locals() |
|
53 | 53 | for name in __all__: |
|
54 | 54 | __import__(name,glob,loc,[]) |
|
55 | 55 | |
|
56 | 56 | # Release data |
|
57 | 57 | from IPython import Release # do it explicitly so pydoc can see it - pydoc bug |
|
58 | 58 | __author__ = '%s <%s>\n%s <%s>\n%s <%s>' % \ |
|
59 | 59 | ( Release.authors['Fernando'] + Release.authors['Janko'] + \ |
|
60 | 60 | Release.authors['Nathan'] ) |
|
61 | 61 | __license__ = Release.license |
|
62 | 62 | __version__ = Release.version |
|
63 | 63 | __revision__ = Release.revision |
|
64 | 64 | |
|
65 | 65 | # Namespace cleanup |
|
66 | 66 | del name,glob,loc |
General Comments 0
You need to be logged in to leave comments.
Login now