def activate(self):
"""
When a source appears in memory, set up the text labels for its class.
"""
if self.texts is None:
self.__class__.texts = {}
for language in ('nl', 'en'):
texts = self.__class__.texts[language] = {}
attr = 'TEXTS_' + language.upper()
reflect.accumulateClassDict(self.__class__, attr, texts)
def parseElement(self, element):
"""
Parse the stanza element.
This is called with the stanza's element when a L{Stanza} is
created using L{fromElement}. It parses the stanza's core attributes
(addressing, type and id), strips the namespace from the stanza
element for easier transport across streams and passes on
child elements for further parsing.
Child element parsers are defined by providing a C{childParsers}
attribute on a subclass, as a mapping from (URI, name) to the name
of the handler on C{self}. C{parseElement} will accumulate
C{childParsers} from its class hierarchy, iterate over the child
elements and pass it to matching handlers based on the child element's
URI and name. The special key of C{None} can be used to pass all
child elements to.
"""
if element.hasAttribute('from'):
self.sender = jid.internJID(element['from'])
if element.hasAttribute('to'):
self.recipient = jid.internJID(element['to'])
self.stanzaType = element.getAttribute('type')
self.stanzaID = element.getAttribute('id')
# Save element
stripNamespace(element)
self.element = element
# accumulate all childHandlers in the class hierarchy of Class
handlers = {}
reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
for child in element.elements():
try:
handler = handlers[child.uri, child.name]
except KeyError:
try:
handler = handlers[None]
except KeyError:
continue
getattr(self, handler)(child)
def parseElement(self, element):
"""
Parse the stanza element.
This is called with the stanza's element when a L{Stanza} is
created using L{fromElement}. It parses the stanza's core attributes
(addressing, type and id), strips the namespace from the stanza
element for easier transport across streams and passes on
child elements for further parsing.
Child element parsers are defined by providing a C{childParsers}
attribute on a subclass, as a mapping from (URI, name) to the name
of the handler on C{self}. C{parseElement} will accumulate
C{childParsers} from its class hierarchy, iterate over the child
elements and pass it to matching handlers based on the child element's
URI and name. The special key of C{None} can be used to pass all
child elements to.
"""
if element.hasAttribute('from'):
self.sender = jid.internJID(element['from'])
if element.hasAttribute('to'):
self.recipient = jid.internJID(element['to'])
self.stanzaType = element.getAttribute('type')
self.stanzaID = element.getAttribute('id')
# Save element
stripNamespace(element)
self.element = element
# accumulate all childHandlers in the class hierarchy of Class
handlers = {}
reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
for child in element.elements():
try:
handler = handlers[child.uri, child.name]
except KeyError:
try:
handler = handlers[None]
except KeyError:
continue
getattr(self, handler)(child)
def parseElement(self, element):
if element.hasAttribute('from'):
self.sender = jid.internJID(element['from'])
if element.hasAttribute('to'):
self.recipient = jid.internJID(element['to'])
self.stanzaType = element.getAttribute('type')
self.stanzaID = element.getAttribute('id')
# Save element
stripNamespace(element)
self.element = element
# accumulate all childHandlers in the class hierarchy of Class
handlers = {}
reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
for child in element.elements():
try:
handler = handlers[child.uri, child.name]
except KeyError:
pass
else:
getattr(self, handler)(child)
def parseElement(self, element):
if element.hasAttribute('from'):
self.sender = jid.internJID(element['from'])
if element.hasAttribute('to'):
self.recipient = jid.internJID(element['to'])
self.stanzaType = element.getAttribute('type')
self.stanzaID = element.getAttribute('id')
# Save element
stripNamespace(element)
self.element = element
# accumulate all childHandlers in the class hierarchy of Class
handlers = {}
reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
for child in element.elements():
try:
handler = handlers[child.uri, child.name]
except KeyError:
pass
else:
getattr(self, handler)(child)
def __init__(self):
parameters = {}
reflect.accumulateClassDict(self.__class__, "parameters", parameters)
self.parameters = parameters
iterFixItem(self)
def __init__(self):
parameters = {}
reflect.accumulateClassDict(self.__class__, "parameters", parameters)
self.parameters = parameters
super(Config, self).__init__(
(n, v.default) for n, v in parameters.iteritems())