Class t.w.x.d.Element(object):

Part of twisted.words.xish.domish View Source View In Hierarchy

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 C{uri} and C{name}
attributes, where C{uri} holds the namespace URI. There is also a default
namespace, for child elements. This is stored in the C{defaultUri}
attribute. Note that C{''} means the empty namespace.

Serialization of Elements through C{toXml()} will use these attributes
for generating proper serialized XML. When both C{uri} and C{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: C{None}.

Using C{None} as the value for C{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, C{None} for C{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 C{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 C{jabber:client} namespace from the root element.
Note that this renders the same as using C{''} instead of C{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'.

@type uri: L{unicode} or None
@ivar uri: URI of this Element's name

@type name: L{unicode}
@ivar name: Name of this Element

@type defaultUri: L{unicode} or None
@ivar defaultUri: URI this Element exists within

@type children: L{list}
@ivar children: List of child Elements and content

@type parent: L{Element}
@ivar parent: Reference to the parent Element, if any.

@type attributes: L{dict}
@ivar attributes: Dictionary of attributes associated with this Element.

@type localPrefixes: L{dict}
@ivar localPrefixes: Dictionary of namespace declarations on this
                     element. The key is the prefix to bind the
                     namespace uri to.

Method	__init__
Method	__getattr__	Undocumented
Method	__getitem__	Undocumented
Method	__delitem__	Undocumented
Method	__setitem__	Undocumented
Method	__str__	Retrieve the first CData (content) node
Method	_dqa	Dequalify an attribute key as needed
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
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

def __init__(self, qname, defaultUri=None, attribs=None, localPrefixes=None): (source)

overridden in twisted.words.protocols.jabber.client.IQ, twisted.words.protocols.jabber.xmlstream.IQ

Parameters	qname	Tuple of (uri, name)
	defaultUri	The default URI of the element; defaults to the URI specified in `qname`
	attribs	Dictionary of attributes
	localPrefixes	Dictionary 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 __str__(self): (source)

Retrieve the first CData (content) node

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)

from twisted.words.xish.domish.IElement

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)

from twisted.words.xish.domish.IElement

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.

Parameters	name	element 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`) )
	defaultUri	default namespace URI for child elements. If `None`, this is inherited from this element. (type: `unicode` )
	content	text contained by the new element. (type: `unicode` )
Returns	the 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): (source)

Iterate across all children of this Element that are Elements.

def toXml(self, prefixes=None, closeElement=1, defaultUri='', prefixesInScope=None): (source)

from twisted.words.xish.domish.IElement

Serialize this Element and all children to a string.

def firstChildElement(self): (source)

Undocumented

API Documentation for twisted, generated by pydoctor.