def get_body(self, lang=None):
"""Return the contents of the HTML body."""
if lang is None:
lang = self.get_lang()
bodies = self.xml.findall('{%s}body' % XHTML_NS)
if lang == '*':
result = OrderedDict()
for body in bodies:
body_lang = body.attrib.get('{%s}lang' % self.xml_ns, '')
body_result = []
body_result.append(body.text if body.text else '')
for child in body:
body_result.append(tostring(child, xmlns=XHTML_NS))
body_result.append(body.tail if body.tail else '')
result[body_lang] = ''.join(body_result)
return result
else:
for body in bodies:
if body.attrib.get('{%s}lang' % self.xml_ns, self.get_lang()) == lang:
result = []
result.append(body.text if body.text else '')
for child in body:
result.append(tostring(child, xmlns=XHTML_NS))
result.append(body.tail if body.tail else '')
return ''.join(result)
return ''
def get_features(self):
"""
"""
features = OrderedDict()
for (name, lang), plugin in self.plugins.items():
features[name] = plugin
return features
def get_fields(self, use_dict=False):
fields = OrderedDict()
fields_xml = self.xml.findall('{%s}field' % self.namespace)
for field_xml in fields_xml:
field = FormField(xml=field_xml)
fields[field['var']] = field
return fields
def get_fields(self, use_dict=False):
fields = OrderedDict()
fieldsXML = self.xml.findall('{%s}field' % FormField.namespace)
for fieldXML in fieldsXML:
field = FormField(xml=fieldXML)
fields[field['var']] = field
return fields
def testCancelType(self):
"""Test that setting type to 'cancel' clears all fields"""
msg = self.Message()
form = msg['form']
fields = OrderedDict()
fields['f1'] = {'type': 'text-single',
'label': 'Username',
'required': True}
fields['f2'] = {'type': 'text-private',
'label': 'Password',
'required': True}
fields['f3'] = {'type': 'text-multi',
'label': 'Message',
'value': 'Enter message.\nA long one even.'}
fields['f4'] = {'type': 'list-single',
'label': 'Message Type',
'options': [{'label': 'Cool!',
'value': 'cool'},
{'label': 'Urgh!',
'value': 'urgh'}]}
form['fields'] = fields
form['type'] = 'cancel'
self.check(form, """
<x xmlns="jabber:x:data" type="cancel" />
""")
def get_reported(self):
fields = OrderedDict()
xml = self.xml.findall('{%s}reported/{%s}field' %
(self.namespace, FormField.namespace))
for field in xml:
field = FormField(xml=field)
fields[field['var']] = field
return fields
def get_reported(self):
reported = OrderedDict()
fields = self.xml.findall('{%s}reported/{%s}field' %
(self.namespace, self.namespace))
for field_xml in fields:
field = FormField(xml=field_xml)
reported[field['var']] = field
return reported
def get_items(self):
items = []
itemsXML = self.xml.findall('{%s}item' % self.namespace)
for itemXML in itemsXML:
item = OrderedDict()
fieldsXML = itemXML.findall('{%s}field' % FormField.namespace)
for fieldXML in fieldsXML:
field = FormField(xml=fieldXML)
item[field['var']] = field['value']
items.append(item)
return items
def get_headers(self):
result = OrderedDict()
headers = self.xml.findall('{%s}header' % self.namespace)
for header in headers:
name = header.attrib.get('name', '')
value = header.text
if name in result:
if not isinstance(result[name], set):
result[name] = [result[name]]
else:
result[name] = []
result[name].add(value)
else:
result[name] = value
return result
def testSubmitType(self):
"""Test that setting type to 'submit' clears extra details"""
msg = self.Message()
form = msg['form']
fields = OrderedDict()
fields['f1'] = {'type': 'text-single',
'label': 'Username',
'required': True}
fields['f2'] = {'type': 'text-private',
'label': 'Password',
'required': True}
fields['f3'] = {'type': 'text-multi',
'label': 'Message',
'value': 'Enter message.\nA long one even.'}
fields['f4'] = {'type': 'list-single',
'label': 'Message Type',
'options': [{'label': 'Cool!',
'value': 'cool'},
{'label': 'Urgh!',
'value': 'urgh'}]}
form['fields'] = fields
form['type'] = 'submit'
form['values'] = {'f1': 'username',
'f2': 'hunter2',
'f3': 'A long\nmultiline\nmessage',
'f4': 'cool'}
self.check(form, """
<x xmlns="jabber:x:data" type="submit">
<field var="f1">
<value>username</value>
</field>
<field var="f2">
<value>hunter2</value>
</field>
<field var="f3">
<value>A long</value>
<value>multiline</value>
<value>message</value>
</field>
<field var="f4">
<value>cool</value>
</field>
</x>
""", use_values=False)
def __init__(self, xml=None, parent=None):
self._index = 0
#: The underlying XML object for the stanza. It is a standard
#: :class:`xml.etree.cElementTree` object.
self.xml = xml
#: An ordered dictionary of plugin stanzas, mapped by their
#: :attr:`plugin_attrib` value.
self.plugins = OrderedDict()
#: A list of child stanzas whose class is included in
#: :attr:`plugin_iterables`.
self.iterables = []
#: The name of the tag for the stanza's root element. It is the
#: same as calling :meth:`tag_name()` and is formatted as
#: ``'{namespace}elementname'``.
self.tag = self.tag_name()
#: A :class:`weakref.weakref` to the parent stanza, if there is one.
#: If not, then :attr:`parent` is ``None``.
self.parent = None
if parent is not None:
self.parent = weakref.ref(parent)
if self.subitem is not None:
for sub in self.subitem:
self.plugin_iterables.add(sub)
if self.setup(xml):
# If we generated our own XML, then everything is ready.
return
# Initialize values using provided XML
for child in self.xml.getchildren():
if child.tag in self.plugin_tag_map:
plugin_class = self.plugin_tag_map[child.tag]
plugin = plugin_class(child, self)
self.plugins[plugin.plugin_attrib] = plugin
if plugin_class in self.plugin_iterables:
self.iterables.append(plugin)
def __init__(self, xml=None, parent=None):
"""
Create a new stanza object.
Arguments:
xml -- Initialize the stanza with optional existing XML.
parent -- Optional stanza object that contains this stanza.
"""
self.xml = xml
self.plugins = OrderedDict()
self.iterables = []
self._index = 0
self.tag = self.tag_name()
if parent is None:
self.parent = None
else:
self.parent = weakref.ref(parent)
ElementBase.values = property(ElementBase._get_stanza_values,
ElementBase._set_stanza_values)
if self.subitem is not None:
for sub in self.subitem:
self.plugin_iterables.add(sub)
if self.setup(xml):
# If we generated our own XML, then everything is ready.
return
# Initialize values using provided XML
for child in self.xml.getchildren():
if child.tag in self.plugin_tag_map:
plugin = self.plugin_tag_map[child.tag]
self.plugins[plugin.plugin_attrib] = plugin(child, self)
for sub in self.plugin_iterables:
if child.tag == "{%s}%s" % (sub.namespace, sub.name):
self.iterables.append(sub(child, self))
break
def __init__(self, *args, **kwargs):
"""
"""
ElementBase.__init__(self, *args, **kwargs)
self.field = OrderedDict()
self.addField = self.add_field
self.addReported = self.add_reported
self.addItem = self.add_item
self.setItems = self.set_items
self.delItems = self.del_items
self.getItems = self.get_items
self.getInstructions = self.get_instructions
self.setInstructions = self.set_instructions
self.delInstructions = self.del_instructions
self.getFields = self.get_fields
self.setFields = self.set_fields
self.delFields = self.del_fields
self.getValues = self.get_values
self.setValues = self.set_values
self.getReported = self.get_reported
self.setReported = self.set_reported
self.delReported = self.del_reported
def testStarLang(self):
"""Test using interface|*."""
class TestStanza(ElementBase):
name = 'foo'
namespace = 'test'
interfaces = set(['test'])
sub_interfaces = interfaces
lang_interfaces = interfaces
data = OrderedDict()
data['en'] = 'hi'
data['fr'] = 'bonjour'
data['no'] = 'hej'
stanza = TestStanza()
stanza['test|*'] = data
self.check(
stanza, """
<foo xmlns="test">
<test xml:lang="en">hi</test>
<test xml:lang="fr">bonjour</test>
<test xml:lang="no">hej</test>
</foo>
""")
data2 = stanza['test|*']
self.assertEqual(data, data2,
"Did not extract expected language data: %s" % data2)
del stanza['test|*']
self.check(stanza, """
<foo xmlns="test" />
""")
#: The reverse mapping of escape sequences to their original forms.
JID_UNESCAPE_TRANSFORMATIONS = {
'\\20': ' ',
'\\22': '"',
'\\26': '&',
'\\27': "'",
'\\2f': '/',
'\\3a': ':',
'\\3c': '<',
'\\3e': '>',
'\\40': '@',
'\\5c': '\\'
}
JID_CACHE = OrderedDict()
JID_CACHE_LOCK = threading.Lock()
JID_CACHE_MAX_SIZE = 1024
def _cache(key, parts, locked):
JID_CACHE[key] = (parts, locked)
if len(JID_CACHE) > JID_CACHE_MAX_SIZE:
with JID_CACHE_LOCK:
while len(JID_CACHE) > JID_CACHE_MAX_SIZE:
found = None
for key, item in JID_CACHE.items():
if not item[1]: # if not locked
found = key
break
if not found: # more than MAX_SIZE locked
def testAddField(self):
"""Testing adding fields to a data form."""
msg = self.Message()
form = msg['form']
form.addField(var='f1',
ftype='text-single',
label='Text',
desc='A text field',
required=True,
value='Some text!')
self.check(msg, """
<message>
<x xmlns="jabber:x:data" type="form">
<field var="f1" type="text-single" label="Text">
<desc>A text field</desc>
<required />
<value>Some text!</value>
</field>
</x>
</message>
""")
fields = OrderedDict()
fields['f1'] = {'type': 'text-single',
'label': 'Username',
'required': True}
fields['f2'] = {'type': 'text-private',
'label': 'Password',
'required': True}
fields['f3'] = {'type': 'text-multi',
'label': 'Message',
'value': 'Enter message.\nA long one even.'}
fields['f4'] = {'type': 'list-single',
'label': 'Message Type',
'options': [{'label': 'Cool!',
'value': 'cool'},
{'label': 'Urgh!',
'value': 'urgh'}]}
form['fields'] = fields
self.check(msg, """
<message>
<x xmlns="jabber:x:data" type="form">
<field var="f1" type="text-single" label="Username">
<required />
</field>
<field var="f2" type="text-private" label="Password">
<required />
</field>
<field var="f3" type="text-multi" label="Message">
<value>Enter message.</value>
<value>A long one even.</value>
</field>
<field var="f4" type="list-single" label="Message Type">
<option label="Cool!">
<value>cool</value>
</option>
<option label="Urgh!">
<value>urgh</value>
</option>
</field>
</x>
</message>
""")
def get_fields(self, use_dict=False):
fields = OrderedDict()
for stanza in self['substanzas']:
if isinstance(stanza, FormField):
fields[stanza['var']] = stanza
return fields
def get_values(self):
values = OrderedDict()
fields = self['fields']
for var in fields:
values[var] = fields[var]['value']
return values
