class Policy(XMLElement, ListElement):
_xml_tag = 'policy-element'
_xml_namespace = namespace
_xml_extension_type = ElementExtension
_xml_document = ResourceListsDocument
id = XMLElementID('id', type=ID, required=True, test_equal=True)
uri = XMLAttribute('uri', type=AnyURI, required=True, test_equal=True)
name = XMLElementChild('name', type=Name, required=True, test_equal=True)
dialog = XMLElementChild('dialog', type=DialogHandling, required=True, test_equal=True)
presence = XMLElementChild('presence', type=PresenceHandling, required=True, test_equal=True)
def __init__(self, id, uri, name='', presence_handling=None, dialog_handling=None):
XMLElement.__init__(self)
self.id = id
self.uri = uri
self.name = name
self.dialog = dialog_handling or DialogHandling('default', False)
self.presence = presence_handling or PresenceHandling('default', False)
def __unicode__(self):
return str(self.uri)
def __repr__(self):
return '%s(%r, %r, %r, %r, %r)' % (self.__class__.__name__, self.id, self.uri, self.name, self.presence, self.dialog)
class DeviceInfo(XMLElement, ServiceExtension):
_xml_tag = 'device-info'
_xml_namespace = agp_pidf_namespace
_xml_document = PIDFDocument
_xml_children_order = {Description.qname: 0, UserAgent.qname: 1}
id = XMLElementID('id', type=str, required=True, test_equal=True)
description = XMLElementChild('description',
type=Description,
required=False,
test_equal=True)
user_agent = XMLElementChild('user_agent',
type=UserAgent,
required=False,
test_equal=True)
time_offset = XMLElementChild('time_offset',
type=TimeOffset,
required=False,
test_equal=True)
def __init__(self,
id,
description=None,
user_agent=None,
time_offset=None):
XMLElement.__init__(self)
self.id = id
self.description = description
self.user_agent = user_agent
self.time_offset = time_offset
def __repr__(self):
return '%s(%r, %r, %r, %r)' % (self.__class__.__name__, self.id,
self.description, self.user_agent,
self.time_offset)
class IMDNMessage(XMLRootElement):
_xml_tag = 'imdn'
_xml_namespace = namespace
_xml_document = IMDNDocument
_xml_children_order = {MessageId.qname: 0,
DateTime.qname: 1,
RecipientUri.qname: 2,
OriginalRecipientUri.qname: 3,
Subject.qname: 4,
DeliveryNotification.qname: 5,
DisplayNotification.qname: 6,
ProcessingNotification.qname: 7,
None: 8}
message_id = XMLElementChild('message_id', type=MessageId, required=True, test_equal=True)
datetime = XMLElementChild('datetime', type=DateTime, required=True, test_equal=True)
recipient_uri = XMLElementChild('recipient_uri', type=RecipientUri, required=False, test_equal=True)
original_recipient_uri = XMLElementChild('original_recipient_uri', type=OriginalRecipientUri, required=False, test_equal=True)
subject = XMLElementChild('subject', type=Subject, required=False, test_equal=True)
notification = XMLElementChoiceChild('notification', types=(DisplayNotification, DeliveryNotification, ProcessingNotification), required=True, test_equal=True)
def __init__(self, message_id=None, datetime=None, recipient_uri=None, original_recipient_uri=None, subject=None, notification=None):
XMLRootElement.__init__(self)
self.message_id = message_id
self.datetime = datetime
self.recipient_uri = recipient_uri
self.original_recipient_uri = original_recipient_uri if original_recipient_uri is not None else recipient_uri
self.subject = subject
self.notification = notification
class PresenceContent(XMLRootElement):
_xml_tag = 'content'
_xml_namespace = namespace
_xml_document = PresenceContentDocument
_xml_children_order = {
MIMEType.qname: 0,
Encoding.qname: 1,
Description.qname: 2,
Data.qname: 3,
None: 4
}
mime_type = XMLElementChild('mime_type',
type=MIMEType,
required=False,
test_equal=True)
encoding = XMLElementChild('encoding',
type=Encoding,
required=False,
test_equal=True)
description = XMLElementChild('description',
type=Description,
required=False,
test_equal=True)
data = XMLElementChild('data', type=Data, required=True, test_equal=True)
def __init__(self, data, mime_type=None, encoding=None, description=None):
XMLRootElement.__init__(self)
self.data = data
self.mime_type = mime_type
self.encoding = encoding
self.description = description
class Group(XMLElement, ListElement):
_xml_tag = 'group'
_xml_namespace = namespace
_xml_extension_type = ElementExtension
_xml_document = ResourceListsDocument
id = XMLElementID('id', type=ID, required=True, test_equal=True)
name = XMLElementChild('name', type=Name, required=True, test_equal=True)
contacts = XMLElementChild('contacts',
type=ContactList,
required=True,
test_equal=True)
def __init__(self, id, name, contacts=[]):
XMLElement.__init__(self)
self.id = id
self.name = name
self.contacts = ContactList(contacts)
def __unicode__(self):
return str(self.name)
def __repr__(self):
return '%s(%r, %r, contacts=%r)' % (self.__class__.__name__, self.id,
self.name, list(self.contacts))
class UrisTypeEntry(XMLElement):
_xml_tag = 'entry'
_xml_namespace = namespace
_xml_document = ConferenceDocument
state = XMLAttribute('state', type=State, required=False, test_equal=False)
uri = XMLElementChild('uri', type=URI, required=True, test_equal=True)
display_text = XMLElementChild('display_text',
type=DisplayText,
required=False,
test_equal=True)
purpose = XMLElementChild('purpose',
type=UrisTypePurpose,
required=False,
test_equal=True)
modified = XMLElementChild('modified',
type=UrisTypeModified,
required=False,
test_equal=True)
def __init__(self,
uri,
state=None,
display_text=None,
purpose=None,
modified=None):
XMLElement.__init__(self)
self.uri = uri
self.state = state
self.display_text = display_text
self.purpose = purpose
self.modified = modified
class AvailableMediaEntry(XMLElement):
_xml_tag = 'entry'
_xml_namespace = namespace
_xml_document = ConferenceDocument
_xml_children_order = {
DisplayText.qname: 0,
MediaType.qname: 1,
MediaTypeStatus.qname: 2,
None: 3
}
label = XMLAttribute('label', type=str, required=True, test_equal=False)
media_type = XMLElementChild('media_type',
type=MediaType,
required=True,
test_equal=True)
display_text = XMLElementChild('display_text',
type=DisplayText,
required=False,
test_equal=True)
status = XMLElementChild('status',
type=MediaTypeStatus,
required=False,
test_equal=True)
def __init__(self, label, media_type, display_text=None, status=None):
XMLElement.__init__(self)
self.label = label
self.media_type = media_type
self.display_text = display_text
self.status = status
class Sip(XMLElement):
_xml_tag = 'sip'
_xml_namespace = namespace
_xml_document = ConferenceDocument
display_text = XMLElementChild('display_text',
type=DisplayText,
required=False,
test_equal=True)
call_id = XMLElementChild('call_id',
type=CallId,
required=False,
test_equal=True)
from_tag = XMLElementChild('from_tag',
type=FromTag,
required=False,
test_equal=True)
to_tag = XMLElementChild('to_tag',
type=ToTag,
required=False,
test_equal=True)
def __init__(self,
display_text=None,
call_id=None,
from_tag=None,
to_tag=None):
XMLElement.__init__(self)
self.display_text = display_text
self.call_id = call_id
self.from_tag = from_tag
self.to_tag = to_tag
class User(XMLListElement):
_xml_tag = 'user'
_xml_namespace = namespace
_xml_document = ConferenceDocument
_xml_item_type = Endpoint
_xml_extension_type = UserExtension
entity = XMLAttribute('entity', type=str, required=True, test_equal=False)
state = XMLAttribute('state', type=State, required=False, test_equal=False)
display_text = XMLElementChild('display_text', type=DisplayText, required=False, test_equal=True)
associated_aors = XMLElementChild('associated_aors', type=AssociatedAors, required=False, test_equal=True)
roles = XMLElementChild('roles', type=Roles, required=False, test_equal=True)
languages = XMLElementChild('languages', type=Languages, required=False, test_equal=True)
cascaded_focus = XMLElementChild('cascaded_focus', type=CascadedFocus, required=False, test_equal=True)
def __init__(self, entity, state='full', display_text=None, associated_aors=None, roles=None, languages=None, cascaded_focus=None, endpoints=[]):
XMLListElement.__init__(self)
self.entity = entity
self.state = state
self.display_text = display_text
self.associated_aors = associated_aors
self.roles = roles
self.languages = languages
self.cascaded_focus = cascaded_focus
self.update(endpoints)
def __repr__(self):
args = ('entity', 'state', 'display_text', 'associated_aors', 'roles', 'languages', 'cascaded_focus')
return "%s(%s, endpoints=%r)" % (self.__class__.__name__, ', '.join("%s=%r" % (name, getattr(self, name)) for name in args), list(self))
class XCAPCapabilities(XMLRootElement):
_xml_tag = 'xcap-caps'
_xml_namespace = namespace
_xml_document = XCAPCapabilitiesDocument
_xml_children_order = {
AUIDS.qname: 0,
Extensions.qname: 1,
Namespaces.qname: 2
}
auids = XMLElementChild('auids',
type=AUIDS,
required=True,
test_equal=True)
extensions = XMLElementChild('extensions',
type=Extensions,
required=False,
test_equal=True)
namespaces = XMLElementChild('namespaces',
type=Namespaces,
required=True,
test_equal=True)
def __init__(self, auids=[], extensions=[], namespaces=[]):
XMLRootElement.__init__(self)
self.auids = AUIDS(auids)
self.extensions = Extensions(extensions)
self.namespaces = Namespaces(namespaces)
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.auids,
self.extensions, self.namespaces)
class Participant(XMLElement):
identity = XMLElementChild('identity', type=Identity, required=False, test_equal=True)
target = XMLElementChild('target', type=Target, required=False, test_equal=True)
def __init__(self, identity=None, target=None):
XMLElement.__init__(self)
self.identity = identity
self.target = target
class Privacy(XMLElement, PersonExtension):
__metaclass__ = PrivacyType
_xml_tag = 'privacy'
_xml_namespace = namespace
_xml_document = PIDFDocument
_xml_children_order = {RPIDNote.qname: 0,
AudioPrivacy.qname: 1,
TextPrivacy.qname: 2,
VideoPrivacy.qname: 3}
id = XMLAttribute('id', type=str, required=False, test_equal=True)
since = XMLAttribute('since', xmlname='from', type=DateTime, required=False, test_equal=True)
until = XMLAttribute('until', type=DateTime, required=False, test_equal=True)
audio = XMLElementChild('audio', type=AudioPrivacy, required=False, test_equal=True)
text = XMLElementChild('text', type=TextPrivacy, required=False, test_equal=True)
video = XMLElementChild('video', type=VideoPrivacy, required=False, test_equal=True)
unknown = property(lambda self: all(getattr(self, name) is None for name in self._privacy_attributes))
_note_map = NoteMap()
def __init__(self, id=None, since=None, until=None, notes=[], audio=False, text=False, video=False):
super(Privacy, self).__init__()
self.id = id
self.since = since
self.until = until
self.audio = audio
self.text = text
self.video = video
self.notes.update(notes)
@property
def notes(self):
return NoteList(self, RPIDNote)
def __eq__(self, other):
if isinstance(other, Privacy):
return super(Privacy, self).__eq__(other) and self.notes == other.notes
else:
return NotImplemented
def __repr__(self):
return '%s(%r, %r, %r, %r, %r, %r, %r)' % (self.__class__.__name__, self.id, self.since, self.until, list(self.notes), self.audio, self.text, self.video)
def _parse_element(self, element):
self.notes._parse_element(element)
def _build_element(self):
if self.unknown:
if self.element.find('{%s}unknown' % self._xml_namespace) is None:
etree.SubElement(self.element, '{%s}unknown' % self._xml_namespace, nsmap=self._xml_document.nsmap)
else:
unknown_element = self.element.find('{%s}unknown' % self._xml_namespace)
if unknown_element is not None:
self.element.remove(unknown_element)
self.notes._build_element()
class Device(XMLElement):
_xml_tag = 'device'
_xml_namespace = dm_namespace
_xml_document = PIDFDocument
_xml_extension_type = DeviceExtension
_xml_children_order = {
None: 0,
DeviceID.qname: 1,
DMNote.qname: 2,
DeviceTimestamp.qname: 3
}
id = XMLElementID('id', type=ID, required=True, test_equal=True)
device_id = XMLElementChild('device_id',
type=DeviceID,
required=False,
test_equal=True)
timestamp = XMLElementChild('timestamp',
type=DeviceTimestamp,
required=False,
test_equal=True)
_note_map = NoteMap()
def __init__(self, id, device_id=None, notes=[], timestamp=None):
XMLElement.__init__(self)
self.id = id
self.device_id = device_id
self.timestamp = timestamp
self.notes.update(notes)
@property
def notes(self):
return NoteList(self, DMNote)
def __eq__(self, other):
if isinstance(other, Device):
return super(Device,
self).__eq__(other) and self.notes == other.notes
else:
return self.id == other
def __repr__(self):
return '%s(%r, %r, %r, %r)' % (self.__class__.__name__, self.id,
self.device_id, list(
self.notes), self.timestamp)
def _parse_element(self, element):
super(Device, self)._parse_element(element)
self.notes._parse_element(element)
def _build_element(self):
super(Device, self)._build_element()
self.notes._build_element()
class ConferenceDescription(XMLElement):
_xml_tag = 'conference-description'
_xml_namespace = namespace
_xml_document = ConferenceDocument
_xml_extension_type = ConferenceDescriptionExtension
display_text = XMLElementChild('display_text', type=DisplayText, required=False, test_equal=True)
subject = XMLElementChild('subject', type=Subject, required=False, test_equal=True)
free_text = XMLElementChild('free_text', type=FreeText, required=False, test_equal=True)
keywords = XMLElementChild('keywords', type=Keywords, required=False, test_equal=True)
conf_uris = XMLElementChild('conf_uris', type=ConfUris, required=False, test_equal=True)
service_uris = XMLElementChild('service_uris', type=ServiceUris, required=False, test_equal=True)
maximum_user_count = XMLElementChild('maximum_user_count', type=MaximumUserCount, required=False, test_equal=True)
available_media = XMLElementChild('available_media', type=AvailableMedia, required=False, test_equal=True)
def __init__(self, display_text=None, subject=None, free_text=None, keywords=None, conf_uris=None, service_uris=None, maximum_user_count=None, available_media=None):
XMLElement.__init__(self)
self.display_text = display_text
self.subject = subject
self.free_text = free_text
self.keywords = keywords
self.conf_uris = conf_uris
self.service_uris = service_uris
self.maximum_user_count = maximum_user_count
self.available_media = available_media
class ConferenceState(XMLElement):
_xml_tag = 'conference-state'
_xml_namespace = namespace
_xml_document = ConferenceDocument
user_count = XMLElementChild('user_count', type=UserCount, required=False, test_equal=True)
active = XMLElementChild('active', type=Active, required=False, test_equal=True)
locked = XMLElementChild('locked', type=Locked, required=False, test_equal=True)
def __init__(self, user_count=None, active=None, locked=None):
XMLElement.__init__(self)
self.user_count = user_count
self.active = active
self.locked = locked
class Endpoint(XMLListElement):
_xml_tag = 'endpoint'
_xml_namespace = namespace
_xml_document = ConferenceDocument
_xml_item_type = Media
entity = XMLAttribute('entity', type=str, required=True, test_equal=False)
state = XMLAttribute('state', type=State, required=False, test_equal=False)
display_text = XMLElementChild('display_text', type=DisplayText, required=False, test_equal=True)
referred = XMLElementChild('referred', type=Referred, required=False, test_equal=True)
status = XMLElementChild('status', type=EndpointStatus, required=False, test_equal=True)
joining_method = XMLElementChild('joining_method', type=JoiningMethod, required=False, test_equal=True)
joining_info = XMLElementChild('joining_info', type=JoiningInfo, required=False, test_equal=True)
disconnection_method = XMLElementChild('disconnection_method', type=DisconnectionMethod, required=False, test_equal=True)
disconnection_info = XMLElementChild('disconnection_info', type=DisconnectionInfo, required=False, test_equal=True)
call_info = XMLElementChild('call_info', type=CallInfo, required=False, test_equal=True)
def __init__(self, entity, state='full', display_text=None, referred=None, status=None, joining_method=None, joining_info=None, disconnection_method=None, disconnection_info=None, call_info=None, media=[]):
XMLListElement.__init__(self)
self.entity = entity
self.state = state
self.display_text = display_text
self.referred = referred
self.status = status
self.joining_method = joining_method
self.joining_info = joining_info
self.disconnection_method = disconnection_method
self.disconnection_info = disconnection_info
self.call_info = call_info
self.update(media)
def __repr__(self):
args = ('entity', 'state', 'display_text', 'referred', 'status', 'joining_method', 'joining_info', 'disconnection_method', 'disconnection_info', 'call_info')
return "%s(%s, media=%r)" % (self.__class__.__name__, ', '.join("%s=%r" % (name, getattr(self, name)) for name in args), list(self))
class ExecutionType(XMLElement):
_xml_tag = None # To be set by the subclass
_xml_namespace = namespace
_xml_document = ConferenceDocument
when = XMLElementChild('when', type=When, required=False, test_equal=True)
reason = XMLElementChild('reason', type=Reason, required=False, test_equal=True)
by = XMLElementChild('by', type=By, required=False, test_equal=True)
def __init__(self, when=None, reason=None, by=None):
XMLElement.__init__(self)
self.when = when
self.reason = reason
self.by = by
class HostInfo(XMLElement):
_xml_tag = 'host-info'
_xml_namespace = namespace
_xml_document = ConferenceDocument
display_text = XMLElementChild('display_text', type=DisplayText, required=False, test_equal=True)
web_page = XMLElementChild('web_page', type=WebPage, required=False, test_equal=True)
uris = XMLElementChild('uris', type=HostInfoUris, required=False, test_equal=True)
def __init__(self, display_text=None, web_page=None, uris=None):
XMLElement.__init__(self)
self.display_text = display_text
self.web_page = web_page
self.uris = uris
class PresenceHandling(XMLElement):
_xml_tag = 'presence'
_xml_namespace = namespace
_xml_document = ResourceListsDocument
policy = XMLElementChild('policy', type=PolicyString, required=True, test_equal=True)
subscribe = XMLElementChild('subscribe', type=Subscribe, required=True, test_equal=True)
def __init__(self, policy, subscribe):
XMLElement.__init__(self)
self.policy = policy
self.subscribe = subscribe
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.policy, self.subscribe)
class Document(XMLElement):
_xml_tag = 'document'
_xml_namespace = namespace
_xml_document = XCAPDiffDocument
selector = XMLElementID('selector', xmlname='sel', type=XCAPURI, required=True, test_equal=True)
new_etag = XMLAttribute('new_etag', xmlname='new-etag', type=str, required=False, test_equal=True)
previous_etag = XMLAttribute('previous_etag', xmlname='previous-etag', type=str, required=False, test_equal=True)
body_not_changed = XMLElementChild('body_not_changed', type=BodyNotChanged, required=False, test_equal=True)
def __init__(self, selector, new_etag=None, previous_etag=None):
XMLElement.__init__(self)
self.selector = selector
self.new_etag = new_etag
self.previous_etag = previous_etag
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.selector, self.new_etag, self.previous_etag)
@property
def empty_body(self):
return self.body_not_changed is not None
@empty_body.setter
def empty_body(self, body_not_changed):
if body_not_changed:
self.body_not_changed = BodyNotChanged()
else:
self.body_not_changed = None
class External(XMLElement, ListElement):
_xml_tag = 'external'
_xml_namespace = namespace
_xml_application = ResourceListsApplication
_xml_children_order = {DisplayName.qname: 0}
anchor = XMLAttribute('anchor',
type=unicode,
required=True,
test_equal=True,
builder=uri_attribute_builder,
parser=uri_attribute_parser)
display_name = XMLElementChild('display_name',
type=DisplayName,
required=False,
test_equal=False)
_xml_id = anchor
def __init__(self, anchor, display_name=None):
XMLElement.__init__(self)
self.anchor = anchor
self.display_name = display_name
def __unicode__(self):
return self.display_name and '"%s" <%s>' % (self.display_name,
self.anchor) or self.anchor
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.anchor,
self.display_name)
class External(XMLElement):
_xml_tag = 'external'
_xml_namespace = namespace
_xml_document = ResourceListsDocument
_xml_children_order = {DisplayName.qname: 0}
anchor = XMLElementID('anchor',
type=AnyURI,
required=True,
test_equal=True)
display_name = XMLElementChild('display_name',
type=DisplayName,
required=False,
test_equal=False)
def __init__(self, anchor, display_name=None):
XMLElement.__init__(self)
self.anchor = anchor
self.display_name = display_name
def __unicode__(self):
return self.display_name and '"%s" <%s>' % (self.display_name,
self.anchor) or self.anchor
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.anchor,
self.display_name)
class Service(XMLElement):
_xml_tag = 'service'
_xml_namespace = namespace
_xml_document = RLSServicesDocument
_xml_children_order = {
List.qname: 0,
ResourceList.qname: 0,
Packages.qname: 1
}
uri = XMLElementID('uri', type=AnyURI, required=True, test_equal=True)
list = XMLElementChoiceChild('list',
types=(ResourceList, List),
required=True,
test_equal=True)
packages = XMLElementChild('packages',
type=Packages,
required=False,
test_equal=True)
def __init__(self, uri, list=None, packages=None):
XMLElement.__init__(self)
self.uri = uri
self.list = list if list is not None else List()
self.packages = packages if packages is not None else Packages()
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.uri,
self.list, self.packages)
class Entry(XMLElement):
_xml_tag = 'entry'
_xml_namespace = namespace
_xml_extension_type = EntryExtension
_xml_document = ResourceListsDocument
_xml_children_order = {DisplayName.qname: 0}
uri = XMLElementID('uri', type=AnyURI, required=True, test_equal=True)
display_name = XMLElementChild('display_name',
type=DisplayName,
required=False,
test_equal=False)
def __init__(self, uri, display_name=None):
XMLElement.__init__(self)
self.uri = uri
self.display_name = display_name
def __unicode__(self):
return self.display_name and '"%s" <%s>' % (self.display_name,
self.uri) or self.uri
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.uri,
self.display_name)
class List(XMLListElement):
_xml_tag = 'list'
_xml_namespace = namespace
_xml_document = ResourceListsDocument
_xml_children_order = {
DisplayName.qname: 0,
Entry.qname: 1,
EntryRef.qname: 1,
External.qname: 1
}
_xml_item_type = (Entry, EntryRef, External, List, ListElement)
name = XMLElementID('name', type=str, required=False, test_equal=True)
display_name = XMLElementChild('display_name',
type=DisplayName,
required=False,
test_equal=False)
def __init__(self, entries=[], name=None, display_name=None):
XMLListElement.__init__(self)
self.name = name
self.display_name = display_name
self.update(entries)
def __repr__(self):
return '%s(%s, %r, %r)' % (self.__class__.__name__, list(self),
self.name, self.display_name)
def __unicode__(self):
name = 'List element'
if self.name is not None:
name += ' %s' % self.name
if self.display_name is not None:
name += ' (%s)' % self.display_name
return name
class ProcessingNotification(NotificationType):
_xml_tag = 'processing-notification'
status = XMLElementChild('status',
type=ProcessingStatus,
required=True,
test_equal=True)
class Entry(XMLElement, ListElement):
_xml_tag = 'entry'
_xml_namespace = namespace
_xml_extension_type = EntryExtension
_xml_application = ResourceListsApplication
_xml_children_order = {DisplayName.qname: 0}
uri = XMLAttribute('uri',
type=unicode,
required=True,
test_equal=True,
builder=uri_attribute_builder,
parser=uri_attribute_parser)
display_name = XMLElementChild('display_name',
type=DisplayName,
required=False,
test_equal=False)
_xml_id = uri
def __init__(self, uri, display_name=None):
XMLElement.__init__(self)
self.uri = uri
self.display_name = display_name
def __unicode__(self):
return self.display_name and u'"%s" <%s>' % (self.display_name,
self.uri) or self.uri
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.uri,
self.display_name)
class DisplayNotification(NotificationType):
_xml_tag = 'display-notification'
status = XMLElementChild('status',
type=DisplayStatus,
required=True,
test_equal=True)
class Device(XMLElement):
_xml_tag = 'device'
_xml_namespace = dm_namespace
_xml_application = PIDFApplication
_xml_extension_type = DeviceExtension
_xml_children_order = {
None: 0,
DeviceID.qname: 1,
DeviceNote.qname: 2,
DeviceTimestamp.qname: 3
}
id = XMLAttribute('id', type=str, required=True, test_equal=True)
device_id = XMLElementChild('device_id',
type=DeviceID,
required=False,
test_equal=True)
timestamp = XMLElementChild('timestamp',
type=DeviceTimestamp,
required=False,
test_equal=True)
notes = NotesAttribute()
_xml_id = id
def __init__(self, id, device_id=None, notes=[], timestamp=None):
XMLElement.__init__(self)
self.id = id
self.device_id = device_id
for note in notes:
self.notes.add(note)
self.timestamp = timestamp
def _parse_element(self, element, *args, **kwargs):
for child in element:
if child.tag == DeviceNote.qname:
self.notes.add(DeviceNote.from_element(child, *args, **kwargs))
def _build_element(self, *args, **kwargs):
for note in self.notes:
note.to_element(*args, **kwargs)
def __repr__(self):
return '%s(%r, %r, [%s], %r)' % (
self.__class__.__name__, self.id, self.device_id, ', '.join(
'%r' % note for note in self.notes), self.timestamp)
__str__ = __repr__
class PlaceIs(XMLElement, PersonExtension):
_xml_tag = 'place-is'
_xml_namespace = namespace
_xml_document = PIDFDocument
_xml_children_order = {RPIDNote.qname: 0,
AudioPlaceInformation.qname: 1,
VideoPlaceInformation.qname: 2,
TextPlaceInformation.qname: 3}
id = XMLAttribute('id', type=str, required=False, test_equal=True)
since = XMLAttribute('since', xmlname='from', type=DateTime, required=False, test_equal=True)
until = XMLAttribute('until', type=DateTime, required=False, test_equal=True)
audio = XMLElementChild('audio', type=AudioPlaceInformation, required=False, test_equal=True)
video = XMLElementChild('video', type=VideoPlaceInformation, required=False, test_equal=True)
text = XMLElementChild('text', type=TextPlaceInformation, required=False, test_equal=True)
_note_map = NoteMap()
def __init__(self, id=None, since=None, until=None, audio=None, video=None, text=None, notes=[]):
XMLElement.__init__(self)
self.id = id
self.since = since
self.until = until
self.audio = audio
self.video = video
self.text = text
self.notes.update(notes)
@property
def notes(self):
return NoteList(self, RPIDNote)
def __eq__(self, other):
if isinstance(other, PlaceIs):
return super(PlaceIs, self).__eq__(other) and self.notes == other.notes
else:
return NotImplemented
def __repr__(self):
return '%s(%r, %r, %r, %r, %r, %r, %r)' % (self.__class__.__name__, self.id, self.since, self.until, self.audio, self.video, self.text, list(self.notes))
def _parse_element(self, element):
self.notes._parse_element(element)
def _build_element(self):
self.notes._build_element()
