##// END OF EJS Templates
Added Jason Orendorff's "Path" module, http://www.jorendorff.com/
vivainio -
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
@@ -27,7 +27,7 b' IPython tries to:'
27 27
28 28 IPython requires Python 2.2 or newer.
29 29
30 $Id: __init__.py 1016 2006-01-14 00:54:23Z vivainio $"""
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>
@@ -45,7 +45,7 b" if sys.version[0:3] < '2.3':"
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>
General Comments 0
You need to be logged in to leave comments. Login now