Spike test for filesystem-path objects
 
 
## Create a path representing an existing directory
 
>>> from filepath import path
>>> p = path( 'c:\temp' )
>>> p
FileSystemPath('c:\temp')
 
## Lists the current contents of the directory
 
>>> p.list()
[FileSystemPath('c:\temp\abook.mab'), FileSystemPath('c:\temp\impab.mab'), FileSystemPath('c:\temp\test.dat')]
 
## Create a new path pointing to a non-existent directory
 
>>> sd = p+'somewhere'
>>> sd.exists()
0
 
## Create the directory pointed to by our path
>>> sd.createDirectory()
>>> sd.exists()
1
 
## Get the parent of the path
>>> sd.parent()
FileSystemPath('c:\temp')
 
## Compare two different versions of the same path
>>> sd.parent() == p
1
 
## Explore the hierarchy of parents a little
## note that sd.parent().parent().parent() returns None
## so isn't really fun to look at in an interactive session
>>> sd.parent().parent()
FileSystemPath('c:\')
>>> sd.root()
FileSystemPath('c:')
 
## Create a deeply nested directory
>>> deep = sd.join( 'this', 'that', 'those' )
>>> deep.createDirectory()
>>> deep.exists()
1
 
## Create a path for a file (deep + 'test.txt') also works
>>> f = deep.join( 'test.txt' )
>>> f.open('w').write( 'some text' )
>>> f
FileSystemPath('c:\temp\somewhere\this\that\those\test.txt')
>>> f.exists()
1
>>> f.size()
9L
>>> f.remove()
>>> f.exists()
0
>>> f.open('w').write( 'some text' )
 
## Remove the entire deeply nested directory
## including files
>>> sd.remove()
>>> f.exists()
0
 
## Demonstrate walking a path hierarchy with simple callbacks
>>> newDirectories = ["why", "not", "me"]
>>> for directory in newDirectories:
...     sub = sd+directory
...     sub.createDirectory ()
...     (sub + 'test.txt').open('w').write( "hello world!")
...     
>>> fileList = []
>>> sd.walk( file = fileList.append )
>>> fileList
[FileSystemPath('c:\temp\somewhere\me\test.txt'), FileSystemPath('c:\temp\somewhere\not\test.txt'), FileSystemPath('c:\temp\somewhere\why\test.txt')]
>>> directoryList = []
>>> sd.walk( pre = directoryList.append )
>>> directoryList
[FileSystemPath('c:\temp\somewhere'), FileSystemPath('c:\temp\somewhere\me'), FileSystemPath('c:\temp\somewhere\not'), FileSystemPath('c:\temp\somewhere\why')]
>>>

Modules
		basictypes.vfs.basepath os

Classes
		BasePath(str) FilePath   class FilePath(BasePath)     Representation of a path in the FileSystem   XXX More documentation XXX Need better support for unc names     Method resolution order: FilePath BasePath str basestring object Methods defined here: __add__ = join(self, *name) association(self) Attempt to determine the platform-specific application association for the path   XXX This is going to be a guess on most platforms I'd assume Windows -- assoc + ftype, or a registry access Mac -- resource fork of the file baseName(self) Get the final fragment of the path as a string baseOnly(self) Is this path reachable using only the base file system canonical(self) Get a canonical version of this path   The new path will be absolute, expanded, case-normalized, and normalized. createDirectory(self, *arguments, **namedarguments) Ensure that a directory exists, if possible   Note: will not work with zipfile directories as they don't really exist, zipfiles should probably recurse down to the ZIP file, create the ZIP file and then, if there is an embedded filesystem (such as an embedded zipfile) create that, otherwise ignore the remainder of the path. drive(self) Get the root drive Path, or None if it doesn't exist exists(self) Return true if this path exists   XXX Should catch primitive errors and raise more useful ones extension(self) Return the file extension, or "" if there is no extension file(self, name) Create a new file path within this directory fragments(self) Get the path as a set of string fragments isAbsolute(self) Return true if this path is an absolute path isDir(self) Return true if we are a directory path isFile(self) Return true if we are a file path isRoot(self) True if this object is the root of its filesystem join(self, *name) Create a new Path from this path plus name list(self, glob='') Return a list of Path objects representing the current contents of this directory mimeType(self) Attempt to determine the platform-specific mime type mapping for this path   XXX Only source I know with this info is wxPython open(self, *arguments, **namedarguments) Attempt to open a file path for reading/writing/appending   returns file( self, *arguments, **namedarguments) for the moment might return a file sub-class eventually parent(self) Get the parent of this path as a Path parents(self) Return all of our parents up to our root permissions(self, mode=None) Attempt to update and/or read permissions for the path   if mode is None --> attempt to read permissions, return None if couldn't succeed if mode is anything else --> call chmod with the value   XXX Eventually, this should support platform-specific permission specifications, such as Secure Linux or WinNT permissions, though I'm not sure how remove(self) (Recursively) remove this object from the filesystem   XXX Should provide options to change permissions if they are incorrectly set (e.g. read-only), and maybe clobber locks/holds if they exist (not even sure that's possible) root(self) Get the root of this path size(self) Attempt to get the (byte) size of the object on disk   Note: calling this on directories does a recursive call adding up the sizes up the files in the directory, which can be rather expensive. split(self) Return our parent path (if available) and our name splitext = extension(self) start(self) Attempt to start the system's default application for this file   This is a serious security consideration, but it's something people are wanting to do all the time, not sure where to stand on it. stat(self) Attempt to run a stat on the object subDir(self, name, *arguments, **namedarguments) Create a new subdirectory path within this directory touch(self) Attempt to update times on the path unc(self) Get the root UNC Path, or None if it doesn't exist   XXX This appears to always return the unc name as lowercase? Data and other attributes defined here: __dict__ = <dictproxy object at 0x01B267B0> dictionary for instance variables (if defined) Methods inherited from BasePath: __eq__(self, other) Attempt to determine if we are equal to other__ __repr__(self) isAncestor(self, other) Return true if we are an ancestor of the other path isChild(self, other) Return true if we are a child of the other path isDescendent(self, other) Return true if we are a descendent of the other path isParent(self, other) Return true if we are the parent of the other path   Other can be a string specifier or a Path object shareRoot(self, other) Return true if we are descended from the same root in the file system sharedRoot(self, other) Return the path of the longest shared prefix for ourselves and other walk(self, file=None, pre=None, post=None) Simple walking method   For directories:         pre(path) is called before starting to process each directory         submember.walk(file,pre,post) is called on each sub-member         post(path) is called after processing all sub-members of the directory For files:         file( path ) is called for each file in each directory Class methods inherited from BasePath: check(cls, value) from type Is the value an instance of this class? coerce(cls, value) from type Coerce value to an instance of this class Data and other attributes inherited from BasePath: __slots__ = () Methods inherited from str: __contains__(...) x.__contains__(y) <==> y in x __ge__(...) x.__ge__(y) <==> x>=y __getattribute__(...) x.__getattribute__('name') <==> x.name __getitem__(...) x.__getitem__(y) <==> x[y] __getnewargs__(...) __getslice__(...) x.__getslice__(i, j) <==> x[i:j]   Use of negative indices is not supported. __gt__(...) x.__gt__(y) <==> x>y __hash__(...) x.__hash__() <==> hash(x) __le__(...) x.__le__(y) <==> x<=y __len__(...) x.__len__() <==> len(x) __lt__(...) x.__lt__(y) <==> x<y __mod__(...) x.__mod__(y) <==> x%y __mul__(...) x.__mul__(n) <==> x*n __ne__(...) x.__ne__(y) <==> x!=y __rmod__(...) x.__rmod__(y) <==> y%x __rmul__(...) x.__rmul__(n) <==> n*x __str__(...) x.__str__() <==> str(x) capitalize(...) S.capitalize() -> string   Return a copy of the string S with only its first character capitalized. center(...) S.center(width) -> string   Return S centered in a string of length width. Padding is done using spaces. count(...) S.count(sub[, start[, end]]) -> int   Return the number of occurrences of substring sub in string S[start:end].  Optional arguments start and end are interpreted as in slice notation. decode(...) S.decode([encoding[,errors]]) -> object   Decodes S using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name registerd with codecs.register_error that is able to handle UnicodeDecodeErrors. encode(...) S.encode([encoding[,errors]]) -> object   Encodes S using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name registered with codecs.register_error that is able to handle UnicodeEncodeErrors. endswith(...) S.endswith(suffix[, start[, end]]) -> bool   Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. expandtabs(...) S.expandtabs([tabsize]) -> string   Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed. find(...) S.find(sub [,start [,end]]) -> int   Return the lowest index in S where substring sub is found, such that sub is contained within s[start,end].  Optional arguments start and end are interpreted as in slice notation.   Return -1 on failure. index(...) S.index(sub [,start [,end]]) -> int   Like S.find() but raise ValueError when the substring is not found. isalnum(...) S.isalnum() -> bool   Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise. isalpha(...) S.isalpha() -> bool   Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise. isdigit(...) S.isdigit() -> bool   Return True if all characters in S are digits and there is at least one character in S, False otherwise. islower(...) S.islower() -> bool   Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise. isspace(...) S.isspace() -> bool   Return True if all characters in S are whitespace and there is at least one character in S, False otherwise. istitle(...) S.istitle() -> bool   Return True if S is a titlecased string and there is at least one character in S, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. isupper(...) S.isupper() -> bool   Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise. ljust(...) S.ljust(width) -> string   Return S left justified in a string of length width. Padding is done using spaces. lower(...) S.lower() -> string   Return a copy of the string S converted to lowercase. lstrip(...) S.lstrip([chars]) -> string or unicode   Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping replace(...) S.replace (old, new[, count]) -> string   Return a copy of string S with all occurrences of substring old replaced by new.  If the optional argument count is given, only the first count occurrences are replaced. rfind(...) S.rfind(sub [,start [,end]]) -> int   Return the highest index in S where substring sub is found, such that sub is contained within s[start,end].  Optional arguments start and end are interpreted as in slice notation.   Return -1 on failure. rindex(...) S.rindex(sub [,start [,end]]) -> int   Like S.rfind() but raise ValueError when the substring is not found. rjust(...) S.rjust(width) -> string   Return S right justified in a string of length width. Padding is done using spaces. rstrip(...) S.rstrip([chars]) -> string or unicode   Return a copy of the string S with trailing whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping sjoin = join(...) S.join(sequence) -> string   Return a string which is the concatenation of the strings in the sequence.  The separator between elements is S. splitlines(...) S.splitlines([keepends]) -> list of strings   Return a list of the lines in S, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true. ssplit = split(...) S.split([sep [,maxsplit]]) -> list of strings   Return a list of the words in the string S, using sep as the delimiter string.  If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator. startswith(...) S.startswith(prefix[, start[, end]]) -> bool   Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. strip(...) S.strip([chars]) -> string or unicode   Return a copy of the string S with leading and trailing whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping swapcase(...) S.swapcase() -> string   Return a copy of the string S with uppercase characters converted to lowercase and vice versa. title(...) S.title() -> string   Return a titlecased version of S, i.e. words start with uppercase characters, all remaining cased characters have lowercase. translate(...) S.translate(table [,deletechars]) -> string   Return a copy of the string S, where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a string of length 256. upper(...) S.upper() -> string   Return a copy of the string S converted to uppercase. zfill(...) S.zfill(width) -> string   Pad a numeric string S with zeros on the left, to fill a field of the specified width.  The string S is never truncated. Data and other attributes inherited from str: __new__ = <built-in method __new__ of type object at 0x1E0CFB00> T.__new__(S, ...) -> a new object with type S, a subtype of T