Known subclasses: twisted.words.protocols.jabber.client.IQ, twisted.words.protocols.jabber.xmlstream.IQ

Implements interfaces: twisted.words.xish.domish.IElement

Represents an XML element node.

An Element contains a series of attributes (name/value pairs), content (character data), and other child Element objects. When building a document with markup (such as HTML or XML), use this object as the starting point.

Element objects fully support XML Namespaces. The fully qualified name of the XML Element it represents is stored in the uri and name attributes, where uri holds the namespace URI. There is also a default namespace, for child elements. This is stored in the defaultUri attribute. Note that '' means the empty namespace.

Serialization of Elements through toXml() will use these attributes for generating proper serialized XML. When both uri and defaultUri are not None in the Element and all of its descendents, serialization proceeds as expected:

>>> from twisted.words.xish import domish
>>> root = domish.Element(('myns', 'root'))
>>> root.addElement('child', content='test')
<twisted.words.xish.domish.Element object at 0x83002ac>
>>> root.toXml()
u"<root xmlns='myns'><child>test</child></root>"

For partial serialization, needed for streaming XML, a special value for namespace URIs can be used: None.

Using None as the value for uri means: this element is in whatever namespace inherited by the closest logical ancestor when the complete XML document has been serialized. The serialized start tag will have a non-prefixed name, and no xmlns declaration will be generated.

Similarly, None for defaultUri means: the default namespace for my child elements is inherited from the logical ancestors of this element, when the complete XML document has been serialized.

To illustrate, an example from a Jabber stream. Assume the start tag of the root element of the stream has already been serialized, along with several complete child elements, and sent off, looking like this:

 <stream:stream xmlns:stream='http://etherx.jabber.org/streams'
                xmlns='jabber:client' to='example.com'>
   ...

Now suppose we want to send a complete element represented by an object message created like:

>>> message = domish.Element((None, 'message'))
>>> message['to'] = 'user@example.com'
>>> message.addElement('body', content='Hi!')
<twisted.words.xish.domish.Element object at 0x8276e8c>
>>> message.toXml()
u"<message to='user@example.com'><body>Hi!</body></message>"

As, you can see, this XML snippet has no xmlns declaration. When sent off, it inherits the jabber:client namespace from the root element. Note that this renders the same as using '' instead of None:

>>> presence = domish.Element(('', 'presence'))
>>> presence.toXml()
u"<presence/>"

However, if this object has a parent defined, the difference becomes clear:

>>> child = message.addElement(('http://example.com/', 'envelope'))
>>> child.addChild(presence)
<twisted.words.xish.domish.Element object at 0x8276fac>
>>> message.toXml()
u"<message to='user@example.com'><body>Hi!</body><envelope xmlns='http://example.com/'><presence xmlns=''/></envelope></message>"

As, you can see, the <presence/> element is now in the empty namespace, not in the default namespace of the parent or the streams'.

Instance Variable uri URI of this Element's name (type: unicode or None)
Instance Variable name Name of this Element (type: unicode)
Instance Variable defaultUri URI this Element exists within (type: unicode or None)
Instance Variable children List of child Elements and content (type: list)
Instance Variable parent Reference to the parent Element, if any. (type: Element)
Instance Variable attributes Dictionary of attributes associated with this Element. (type: dict)
Instance Variable localPrefixes Dictionary of namespace declarations on this element. The key is the prefix to bind the namespace uri to. (type: dict)
Method __init__ No summary
Method __getattr__ Undocumented
Method __getitem__ Undocumented
Method __delitem__ Undocumented
Method __setitem__ Undocumented
Method __unicode__ Retrieve the first CData (content) node
Method __bytes__ Retrieve the first character data node as UTF-8 bytes.
Method getAttribute Retrieve the value of attribname, if it exists
Method hasAttribute Determine if the specified attribute exists
Method compareAttribute Safely compare the value of an attribute against a provided value.
Method swapAttributeValues Swap the values of two attribute.
Method addChild Add a child to this Element.
Method addContent Add some text data to this Element.
Method addElement Create an element and add as child.
Method addRawXml Add a pre-serialized chunk o' XML as a child of this Element.
Method addUniqueId Add a unique (across a given Python session) id attribute to this Element.
Method elements Iterate across all children of this Element that are Elements.
Method toXml Serialize this Element and all children to a string.
Method firstChildElement Undocumented
Method _dqa Dequalify an attribute key as needed
uri =
URI of this Element's name (type: unicode or None)
name =
Name of this Element (type: unicode)
defaultUri =
URI this Element exists within (type: unicode or None)
children =
List of child Elements and content (type: list)
parent =
Reference to the parent Element, if any. (type: Element)
attributes =
Dictionary of attributes associated with this Element. (type: dict)
localPrefixes =
Dictionary of namespace declarations on this element. The key is the prefix to bind the namespace uri to. (type: dict)
def __init__(self, qname, defaultUri=None, attribs=None, localPrefixes=None): (source)
ParametersqnameTuple of (uri, name)
defaultUriThe default URI of the element; defaults to the URI specified in qname
attribsDictionary of attributes
localPrefixesDictionary of namespace declarations on this element. The key is the prefix to bind the namespace uri to.
def __getattr__(self, key): (source)
Undocumented
def __getitem__(self, key): (source)
Undocumented
def __delitem__(self, key): (source)
Undocumented
def __setitem__(self, key, value): (source)
Undocumented
def __unicode__(self): (source)

Retrieve the first CData (content) node

def __bytes__(self): (source)

Retrieve the first character data node as UTF-8 bytes.

def _dqa(self, attr): (source)

Dequalify an attribute key as needed

def getAttribute(self, attribname, default=None): (source)

Retrieve the value of attribname, if it exists

def hasAttribute(self, attrib): (source)

Determine if the specified attribute exists

def compareAttribute(self, attrib, value): (source)

Safely compare the value of an attribute against a provided value.

None-safe.

def swapAttributeValues(self, left, right): (source)

Swap the values of two attribute.

def addChild(self, node): (source)

Add a child to this Element.

def addContent(self, text): (source)

Add some text data to this Element.

def addElement(self, name, defaultUri=None, content=None): (source)

Create an element and add as child.

The new element is added to this element as a child, and will have this element as its parent.

Parametersnameelement name. This can be either a unicode object that contains the local name, or a tuple of (uri, local_name) for a fully qualified name. In the former case, the namespace URI is inherited from this element. (type: unicode or tuple of (unicode, unicode))
defaultUridefault namespace URI for child elements. If None, this is inherited from this element. (type: unicode)
contenttext contained by the new element. (type: unicode)
Returnsthe created element (type: object providing IElement)
def addRawXml(self, rawxmlstring): (source)

Add a pre-serialized chunk o' XML as a child of this Element.

def addUniqueId(self): (source)

Add a unique (across a given Python session) id attribute to this Element.

def elements(self, uri=None, name=None): (source)

Iterate across all children of this Element that are Elements.

Returns a generator over the child elements. If both the uri and name parameters are set, the returned generator will only yield on elements matching the qualified name.

ParametersuriOptional element URI. (type: unicode)
nameOptional element name. (type: unicode)
ReturnsIterator that yields objects implementing IElement.
def toXml(self, prefixes=None, closeElement=1, defaultUri='', prefixesInScope=None): (source)

Serialize this Element and all children to a string.

def firstChildElement(self): (source)
Undocumented
API Documentation for Twisted, generated by pydoctor at 2018-10-15 19:29:43.