New HTML Object Model based on @spug.web.xmlo objects.

Classes
		web.cxml.ElementFactory web.htmlo.HTMLElementFactory web.xmlo.Element web.htmlo.HTMLElement web.htmlo.A web.htmlo.B web.htmlo.Body web.htmlo.Br web.htmlo.Center web.htmlo.Div web.htmlo.Em web.htmlo.Font web.htmlo.Form web.htmlo.H1 web.htmlo.H2 web.htmlo.H3 web.htmlo.H4 web.htmlo.H5 web.htmlo.H6 web.htmlo.H7 web.htmlo.H8 web.htmlo.H9 web.htmlo.HTML web.htmlo.XDoc web.htmlo.Head web.htmlo.I web.htmlo.Img web.htmlo.LI web.htmlo.OL web.htmlo.Option web.htmlo.P web.htmlo.Pre web.htmlo.Script web.htmlo.Select web.htmlo.XSelect web.htmlo.SingleTagElement web.htmlo.Input web.htmlo.Link web.htmlo.Span web.htmlo.Strong web.htmlo.Style web.htmlo.TD web.htmlo.TH web.htmlo.TR web.htmlo.Table web.htmlo.XTable web.htmlo.TextArea web.htmlo.Title web.htmlo.U web.htmlo.UL web.htmlo.XUL web.htmlo.XNull   class A(HTMLElement)       Method resolution order: A HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class B(HTMLElement)       Method resolution order: B HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Body(HTMLElement)       Method resolution order: Body HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Br(HTMLElement)       Method resolution order: Br HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Center(HTMLElement)       Method resolution order: Center HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Div(HTMLElement)       Method resolution order: Div HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Em(HTMLElement)       Method resolution order: Em HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Font(HTMLElement)       Method resolution order: Font HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Form(HTMLElement)       Method resolution order: Form HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H1(HTMLElement)       Method resolution order: H1 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H2(HTMLElement)       Method resolution order: H2 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H3(HTMLElement)       Method resolution order: H3 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H4(HTMLElement)       Method resolution order: H4 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H5(HTMLElement)       Method resolution order: H5 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H6(HTMLElement)       Method resolution order: H6 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H7(HTMLElement)       Method resolution order: H7 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H8(HTMLElement)       Method resolution order: H8 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class H9(HTMLElement)       Method resolution order: H9 HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class HTML(HTMLElement)       Method resolution order: HTML HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class HTMLElement(web.xmlo.Element)       Methods defined here: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class HTMLElementFactory(web.cxml.ElementFactory)       Methods defined here: makeElement(self, name, actualNS)   class Head(HTMLElement)       Method resolution order: Head HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class I(HTMLElement)       Method resolution order: I HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Img(HTMLElement)       Method resolution order: Img HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Input(SingleTagElement)     Attributes:      type::       'entry' (text entryfield), 'submit' (submit button), 'reset'       (reset button), 'password' (password entry field), 'hidden'       (hidden input)    name::       Control id    size::       For 'entry' and 'password' types, this is the width of the field       in columns.    value::       For 'entry' and 'password' types, this is the initial text.  For       buttons, it is the button label.     Method resolution order: Input SingleTagElement HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class LI(HTMLElement)       Method resolution order: LI HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Link(SingleTagElement)       Method resolution order: Link SingleTagElement HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class OL(HTMLElement)       Method resolution order: OL HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Option(HTMLElement)       Method resolution order: Option HTMLElement web.xmlo.Element Methods defined here: set(self, value) Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class P(HTMLElement)       Method resolution order: P HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Pre(HTMLElement)       Method resolution order: Pre HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Script(HTMLElement)       Method resolution order: Script HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Select(HTMLElement)       Method resolution order: Select HTMLElement web.xmlo.Element Methods defined here: set(self, value) Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class SingleTagElement(HTMLElement)       Method resolution order: SingleTagElement HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Span(HTMLElement)       Method resolution order: Span HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Strong(HTMLElement)       Method resolution order: Strong HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Style(HTMLElement)       Method resolution order: Style HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class TD(HTMLElement)     Attributes:      colspan::       Columns of the table to span.    rowspan::       Rows of the table to span.     Method resolution order: TD HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class TH(HTMLElement)       Method resolution order: TH HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class TR(HTMLElement)       Method resolution order: TR HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Table(HTMLElement)     Attributes:      border::       0 for none, 1 for a border.     Method resolution order: Table HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class TextArea(HTMLElement)       Method resolution order: TextArea HTMLElement web.xmlo.Element Methods defined here: set(self, value) Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class Title(HTMLElement)       Method resolution order: Title HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class U(HTMLElement)       Method resolution order: U HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class UL(HTMLElement)       Method resolution order: UL HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class XDoc(HTML)     A complete html document.  Consists of the outer HTML tag with an embedded HEAD tag and BODY tag, both of which are available as public variables:   /head/::    An instance of @Head which represents the HEAD tag of the    document. /body/::    An instance of @Body which represents the BODY tag of the    document.   All sequence and keyword arguments are passed to the BODY tag,  except for the following special attributes:   /title/::    A string representing the title of the document.  This will cause    a TITLE tag to be added to the contents of the HEAD tag.     Method resolution order: XDoc HTML HTMLElement web.xmlo.Element Methods defined here: __init__(self, *parms, **kw) Methods inherited from HTMLElement: formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class XNull(HTMLElement)     This is a tag that simply writes out it's contents with no enclosing element.     Method resolution order: XNull HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class XSelect(Select)     Just like *Select* but automatically wraps all children that are not Option instances as Option instances.     Method resolution order: XSelect Select HTMLElement web.xmlo.Element Methods inherited from Select: set(self, value) Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class XTable(Table)     Just like a *Table* except that all children that are lists or tuples are automatically converted to rows, and all items in those lists that are not *TD*'s are converted to *TD*'s.     Method resolution order: XTable Table HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1   class XUL(UL)     Like an unordered list, but automatically wraps all children that are not list items (LI) in list items.     Method resolution order: XUL UL HTMLElement web.xmlo.Element Methods inherited from HTMLElement: __init__(self, *parms, **kw) formatTo(self, output, indentContent=0, indent=2, xhtml=0) Overrides @spug.web.xml.Element.formatTo() to provide an XHTML  parameter.   parms:    output::       [file.write] output stream    indentContent::       [boolean] if true, multiline content is indented.    indent::       [int] number of characters to indent children    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. populate(self, valueDict) Populates this element and all nested elements from the value dictionary.   If there is a key in valueDict matching a "name" attribute in this element, sets the value of the element in a manner appropriate to the element type.   This method is intended to allow you to populate an entire form from the values in a query dictionary.   The value of the element is set using the @set() method.  This is what is generally overriden to vary the way control values are defined. set(self, value) Sets the value of an element in the manner prescribed for the element.  This is really only relevant for form controls.  The base class version of this just sets the "value" attribute.  Derived classes should override as appropriate. writeTo(self, output, xhtml=0) Overrides @spug.web.xml.Element.writeTo() to provide an XHTML parameter.   parms:    output::       [file.write]    xhtml::       [boolean] if true, node and contents will be written in       XHTML instead of normal HTML. Methods inherited from web.xmlo.Element: __delitem__(self, accessor) __getitem__(self, accessor) Gets the specified attribute or content item, depending on whether /accessor/ is a string (or tuple) or integer.   parms:    accessor::       [string or tuple<string, string> or int] If this is a string       or tuple, returns the associated attribute.  If it is an        integer, returns the associated content item.              If this is a single string, returns the value of an attribute       in the global namespace.  If it is a tuple of two strings,       the first string is a namespace URI.              If this is an integer, returns the value of a child element.       Interspersed text is ignored. __len__(self) Returns the number of content nodes in the element. __nonzero__(self) Because we define "len", we have to define this to always return true so that all instances of @Element are considered "true". __setitem__(self, accessor, value) append(self, val) Appends a new element or text string to the contents of the element.   parms:    val::       [string or @Element] copy(self) Returns a deep copy of the element. deleteItem(self, index) Deletes the item at the specified index from the contents. The more "correct" way to do this is through `__delitem__`: i.e. "#del node[index]#".  However, in Python 2.2.3, doing this to a proxy (as return from the @getParent() method) causes a *SystemError* due to a bug in the weak reference code. get(self, attr, default=None) getActualNamespace(self) Returns the actual namespace of the element name.  The "actual namespace" is the specified namespace if there is one,  it is the default namespace if there was no specified namespace. getAllChildren(self) Returns all child elements (list<@Element>).  This actually returns a reference to an internal list, so the caller should not modify the value returned. getChild(self, namespace, name) Returns the first child with the given name.  Returns None if no such child exists.   parms:    namespace::       [string] namespace URI    name::       [string] getChildren(self, namespace, name) Returns all children with the given name.   parms:    namespace::       [string] namespace URI    name::       [name] getDefaultNamespace(self) Returns the default namespace URI for the node (string or None, None means that the default namespace is the global namespace). getFullName(self) Returns the namespace and name of the of the element  (tuple<string, string>).  Note that the namespace is the  /specified namespace/, not the /actual namespace/. getName(self) Returns the simple unqualified name of the element. getNamespace(self, prefix) Returns the namespace URI for the given prefix.  Returns None if no such prefix is defined.   parms:    prefix::       [string] namespace prefix getParent(self) Returns the parent object (actually, a proxy to the parent object),  *None* if there is no parent. getPrefix(self, uri) Returns the namespace prefix for the given URI.  Returns None if no prefix is found for this URI.   parms:    uri::       [string] namespace URI to find the prefix for getValue(self) Returns the value of the element as one big string.  This will raise a ValueError if the element contains nested child elements. hasChildren(self) Returns true if the element has child elements. hasContents(self) Returns true if the element has contents (children or character data). has_key(self, attr) Returns true if the element has the given attribute.   parms:    attr::       [string or tuple<string, string>] attribute to check for. index(self, item) Returns the index of the item within the contents list (an integer).   parms:    item::       [string or @Element] insert(self, index, val) iterate(self, explorer) Selectively iterates over the tree using the given explorer in  a depth-first traversal.   parms:    explorer::       [callable<any>] This object will be called for the node.       The value it returns indicates how the iteration proceeds.       The following return values are allowed:                 EXPAND::             Iterate over the children of the node.          CONTINUE::             Do not iterate over the children of the node, continue             iteration with the next node in the parent's child list.          ABORT::             Abort iteration. setName = __setName(self, name) Sets the full name of the element.   parms:    name::       [tuple<string, string> or string] Either an unqualified name or       a tuple of namespace URI and local name. setValue = __setValue(self, newValue) Deletes all current contens of the element, and replaces it with the new value.   parms:    newValue::       [string] setdefault(self, attr, default) strip(self, stripContent=0) Strips all "unnecessary" whitespace from the element and all nested elements.  Unncessary whitespace is whitespace between child elements - when using XML for structured data representation,  this is usually just for formatting.   parms:    stripContent::       [boolean] if true, indicates that indentation of content       elements (nodes with no nested children stripEmptyContents(self) If the element contents consists of nothing but whitespace, deletes all contents.  Otherwise makes no changes to the element.   Returns true if contents were removed, false if not.   This can used to "clean out" whitespace content after removing a child element. Data and other attributes inherited from web.xmlo.Element: ABORT = 3 CONTINUE = 2 EXPAND = 1