Module Util

Make the drive letter (if any) upper case.
This is useful because Windows is inconsitent on the case
of the drive letter, which can cause inconsistencies when
calculating command signatures.

Given a string, first determine if it looks like a reference
to a single environment variable, like "$FOO" or "${FOO}".
If so, return that variable with no decorations ("FOO").
If not, return None.

Render a tree of nodes into an ASCII tree view.
root - the root node of the tree
child_func - the function called to get the children of a node
prune - don't visit the same node twice
margin - the format of the left margin to use for children of root.
   1 results in a pipe, and 0 results in no pipe.
visited - a dictionary of visited nodes in the current branch if not prune,
   or in the whole tree if prune.

Print a tree of nodes.  This is like render_tree, except it prints
lines directly instead of creating a string representation in memory,
so that huge trees can be printed.

root - the root node of the tree
child_func - the function called to get the children of a node
prune - don't visit the same node twice
showtags - print status information to the left of each node line
margin - the format of the left margin to use for children of root.
   1 results in a pipe, and 0 results in no pipe.
visited - a dictionary of visited nodes in the current branch if not prune,
   or in the whole tree if prune.

Flatten a sequence to a non-nested list.

Flatten() converts either a single scalar or a nested sequence
to a non-nested list. Note that flatten() considers strings
to be scalars instead of sequences like Python would.

Flatten a sequence to a non-nested list.

Same as flatten(), but it does not handle the single scalar
case. This is slightly more efficient when one knows that
the sequence to flatten can not be a scalar.

This prepends newpath elements to the given oldpath.  Will only
add any particular path once (leaving the first one it encounters
and ignoring the rest, to preserve path order), and will
os.path.normpath and os.path.normcase all paths to help assure
this.  This can also handle the case where the given old path
variable is a list instead of a string, in which case a list will
be returned instead of a string.

Example:
  Old Path: "/foo/bar:/foo"
  New Path: "/biz/boom:/foo"
  Result:   "/biz/boom:/foo:/foo/bar"

If delete_existing is 0, then adding a path that exists will
not move it to the beginning; it will stay where it is in the
list.

If canonicalize is not None, it is applied to each element of 
newpath before use.

This appends new path elements to the given old path.  Will
only add any particular path once (leaving the last one it
encounters and ignoring the rest, to preserve path order), and
will os.path.normpath and os.path.normcase all paths to help
assure this.  This can also handle the case where the given old
path variable is a list instead of a string, in which case a list
will be returned instead of a string.

Example:
  Old Path: "/foo/bar:/foo"
  New Path: "/biz/boom:/foo"
  Result:   "/foo/bar:/biz/boom:/foo"

If delete_existing is 0, then adding a path that exists
will not move it to the end; it will stay where it is in the list.

If canonicalize is not None, it is applied to each element of 
newpath before use.

Transforms an absolute path into a native path for the system.
Non-Cygwin version, just leave the path alone.

Return a list of the elements in s, but without duplicates.

For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
unique("abcabc") some permutation of ["a", "b", "c"], and
unique(([1, 2], [2, 3], [1, 2])) some permutation of
[[2, 3], [1, 2]].

For best speed, all sequence elements should be hashable.  Then
unique() will usually work in linear time.

If not possible, the sequence elements should enjoy a total
ordering, and if list(s).sort() doesn't raise TypeError it's
assumed that they do enjoy a total ordering.  Then unique() will
usually work in O(N*log2(N)) time.

If that's not possible either, the sequence elements must support
equality-testing.  Then unique() will usually work in quadratic
time.

Adds either a bound method to an instance or an unbound method to
a class. If name is ommited the name of the specified function
is used by default.
Example:
  a = A()
  def f(self, x, y):
    self.z = x + y
  AddMethod(f, A, "add")
  a.add(2, 4)
  print a.z
  AddMethod(lambda self, i: self.l[i], a, "listIndex")
  print a.listIndex(5)

Collects a list of signatures into an aggregate signature.

signatures - a list of signatures
returns - the aggregate signature

Perform sys.intern() on the passed argument and return the result.
If the input is ineligible (e.g. a unicode string) the original argument is
returned and no exception is thrown.

DictTypes

Value:

DictTypes

ListTypes

Value:

list, UserList

SequenceTypes

Value:

SequenceTypes

StringTypes

Value:

StringTypes

d

Value:

{}