class SidebarsByValEntry(XMLElement):
_xml_tag = 'entry'
_xml_namespace = namespace
_xml_document = ConferenceDocument
entity = XMLAttribute('entity', type=str, required=True, test_equal=False)
state = XMLAttribute('state', type=State, required=False, test_equal=False)
conference_description = XMLElementChild('conference_description', type=ConferenceDescription, required=False, test_equal=True)
host_info = XMLElementChild('host_info', type=HostInfo, required=False, test_equal=True)
conference_state = XMLElementChild('conference_state', type=ConferenceState, required=False, test_equal=True)
users = XMLElementChild('users', type=Users, required=False, test_equal=True)
sidebars_by_ref = XMLElementChild('sidebars_by_ref', type=SidebarsByRef, required=False, test_equal=True)
sidebars_by_val = XMLElementChild('sidebars_by_val', type=SidebarsByVal, required=False, test_equal=True)
def __init__(self, entity, state='full', version=None, conference_description=None, host_info=None, conference_state=None, users=None, sidebars_by_ref=None, sidebars_by_val=None):
XMLElement.__init__(self)
self.entity = entity
self.state = state
self.version = version
self.conference_description = conference_description
self.host_info = host_info
self.conference_state = conference_state
self.users = users
self.sidebars_by_ref = sidebars_by_ref
self.sidebars_by_val = sidebars_by_val
if self.state == "full" and (self.conference_description is None or self.users is None):
raise ValidationError("A full conference document must at least include the <conference-description> and <users> child elements.")
class Replaces(XMLEmptyElement):
_xml_tag = 'replaces'
_xml_namespace = namespace
_xml_document = DialogInfoDocument
call_id = XMLAttribute('call_id',
xmlname='call-id',
type=str,
required=True,
test_equal=True)
local_tag = XMLAttribute('local_tag',
xmlname='local-tag',
type=str,
required=True,
test_equal=True)
remote_tag = XMLAttribute('remote_tag',
xmlname='remote-tag',
type=str,
required=True,
test_equal=True)
def __init__(self, call_id, local_tag, remote_tag):
XMLEmptyElement.__init__(self)
self.call_id = call_id
self.local_tag = local_tag
self.remote_tag = remote_tag
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 Mood(XMLStringListElement, PersonExtension):
_xml_tag = 'mood'
_xml_namespace = namespace
_xml_document = PIDFDocument
_xml_extension_type = MoodElement
_xml_children_order = {RPIDNote.qname: 0}
_xml_item_registry = MoodRegistry
_xml_item_other_type = RPIDOther
_xml_item_extension_type = MoodElement
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)
_note_map = NoteMap()
def __init__(self, id=None, since=None, until=None, moods=[], notes=[]):
XMLElement.__init__(self)
self.id = id
self.since = since
self.until = until
self.update(moods)
self.notes.update(notes)
@property
def notes(self):
return NoteList(self, RPIDNote)
def __eq__(self, other):
if isinstance(other, Mood):
return super(Mood, self).__eq__(other) and self.notes == other.notes
else:
return NotImplemented
def __repr__(self):
return '%s(%r, %r, %r, %r, %r)' % (self.__class__.__name__, self.id, self.since, self.until, list(self), list(self.notes))
def _parse_element(self, element):
super(Mood, self)._parse_element(element)
self.notes._parse_element(element)
def _build_element(self):
super(Mood, self)._build_element()
self.notes._build_element()
def add(self, mood):
if isinstance(mood, basestring):
if mood in self._xml_item_registry.names:
mood = self._xml_item_registry.class_map[mood]()
else:
mood = self._xml_item_other_type.from_string(mood)
unknown_mood = self._xml_item_registry.class_map['unknown']()
if mood == unknown_mood or unknown_mood in self._element_map.itervalues():
self.clear()
super(Mood, self).add(mood)
def check_validity(self):
if not self:
raise ValidationError("Mood element must have at least one value")
super(Mood, self).check_validity()
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 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 Sphere(XMLElement, PersonExtension):
_xml_tag = 'sphere'
_xml_namespace = namespace
_xml_document = PIDFDocument
id = XMLAttribute('id', type=ID, 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)
value = XMLStringChoiceChild('value',
registry=SphereRegistry,
extension_type=SphereElement)
def __init__(self, value=None, id=None, since=None, until=None):
XMLElement.__init__(self)
self.id = id
self.since = since
self.until = until
self.value = value
def __repr__(self):
return '%s(%r, %r, %r, %r)' % (self.__class__.__name__, self.value,
self.id, self.since, self.until)
class List(XMLListRootElement):
_xml_tag = 'list'
_xml_namespace = namespace
_xml_document = RLMIDocument
_xml_item_type = (Name, Resource)
uri = XMLElementID('uri', type=AnyURI, required=True, test_equal=True)
version = XMLAttribute('version',
type=UnsignedInt,
required=True,
test_equal=True)
full_state = XMLAttribute('full_state',
xmlname='fullState',
type=Boolean,
required=True,
test_equal=True)
cid = XMLAttribute('cid', type=str, required=False, test_equal=True)
def __init__(self, uri, version, full_state, cid=None, items=[]):
XMLListElement.__init__(self)
self.uri = uri
self.version = version
self.full_state = full_state
self.cid = cid
self.update(items)
def __repr__(self):
return '%s(%r, version=%r, full_state=%r, cid=%r, items=%r)' % (
self.__class__.__name__, self.uri, self.version, self.full_state,
self.cid, list(self))
class UserInput(XMLStringElement, ServiceExtension, PersonExtension,
DeviceExtension):
_xml_tag = 'user-input'
_xml_namespace = rpid_namespace
_xml_application = PIDFApplication
_xml_lang = False
_xml_value_type = UserInputValue
id = XMLAttribute('id', type=str, required=False, test_equal=True)
last_input = XMLAttribute('last_input',
xmlname='last-input',
type=Timestamp,
required=False,
test_equal=True)
idle_threshold = XMLAttribute('idle_threshold',
xmlname='idle-threshold',
type=UnsignedLong,
required=False,
test_equal=True)
def __init__(self,
value='active',
id=None,
last_input=None,
idle_threshold=None):
XMLStringElement.__init__(self, value)
self.id = id
self.last_input = last_input
self.idle_threshold = idle_threshold
class Dialog(XMLElement):
_xml_tag = 'dialog'
_xml_namespace = namespace
_xml_document = DialogInfoDocument
id = XMLElementID('id', type=str, required=True, test_equal=True)
call_id = XMLAttribute('call_id', xmlname='call-id', type=str, required=False, test_equal=True)
local_tag = XMLAttribute('local_tag', xmlname='local-tag', type=str, required=False, test_equal=True)
remote_tag = XMLAttribute('remote_tag', xmlname='remote-tag', type=str, required=False, test_equal=True)
direction = XMLAttribute('direction', type=DirectionValue, required=False, test_equal=True)
state = XMLElementChild('state', type=DialogState, required=True, test_equal=True)
duration = XMLElementChild('duration', type=Duration, required=False, test_equal=True)
replaces = XMLElementChild('replaces', type=Replaces, required=False, test_equal=True)
referred_by = XMLElementChild('referred_by', type=ReferredBy, required=False, test_equal=True)
local = XMLElementChild('local', type=Local, required=False, test_equal=True)
remote = XMLElementChild('remote', type=Remote, required=False, test_equal=True)
def __init__(self, id, state, call_id=None, local_tag=None, remote_tag=None, direction=None, duration=None, replaces=None, referred_by=None, local=None, remote=None):
XMLElement.__init__(self)
self.id = id
self.state = state
self.call_id = call_id
self.local_tag = local_tag
self.remote_tag = remote_tag
self.direction = direction
self.duration = duration
self.replaces = replaces
self.referred_by = referred_by
self.local = local
self.remote = remote
class Element(XMLElement):
_xml_tag = 'element'
_xml_namespace = namespace
_xml_application = XCAPDiffApplication
selector = XMLAttribute('selector',
xmlname='sel',
type=XCAPURI,
required=True,
test_equal=True)
exists = XMLAttribute('exists',
type=Boolean,
required=False,
test_equal=True)
_xml_id = selector
def __init__(self, selector, exists=None):
XMLElement.__init__(self)
self.selector = selector
self.exists = exists
def _parse_element(self, element, *args, **kwargs):
pass
def _build_element(self, *args, **kwargs):
pass
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.selector,
self.exists)
__str__ = __repr__
class DialogState(XMLStringElement):
_xml_tag = 'state'
_xml_namespace = namespace
_xml_document = DialogInfoDocument
_xml_value_type = DialogStateValue
code = XMLAttribute('code', type=int, required=False, test_equal=True)
event = XMLAttribute('event', type=DialogEventValue, required=False, test_equal=True)
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 PlaceType(XMLElement, PersonExtension):
_xml_tag = 'place-type'
_xml_namespace = namespace
_xml_document = PIDFDocument
_xml_children_order = {RPIDNote.qname: 0}
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)
value = XMLStringChoiceChild('value',
other_type=RPIDOther,
extension_type=PlaceTypeElement)
_note_map = NoteMap()
def __init__(self,
id=None,
since=None,
until=None,
placetype=None,
notes=[]):
super(PlaceType, self).__init__()
self.id = id
self.since = since
self.until = until
self.value = placetype
self.notes.update(notes)
@property
def notes(self):
return NoteList(self, RPIDNote)
def __eq__(self, other):
if isinstance(other, PlaceType):
return super(PlaceType,
self).__eq__(other) and self.notes == other.notes
else:
return NotImplemented
def __repr__(self):
return '%s(%r, %r, %r, %r, %r)' % (self.__class__.__name__, self.id,
self.since, self.until, self.value,
list(self.notes))
def _parse_element(self, element):
self.notes._parse_element(element)
def _build_element(self):
self.notes._build_element()
class Document(XMLElement):
_xml_tag = 'document'
_xml_namespace = namespace
_xml_application = XCAPDiffApplication
selector = XMLAttribute('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)
_xml_id = selector
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 _parse_element(self, element, *args, **kwargs):
pass
def _build_element(self, *args, **kwargs):
pass
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.selector,
self.new_etag, self.previous_etag)
__str__ = __repr__
def _get_empty_body(self):
return self.body_not_changed is not None
def _set_empty_body(self, body_not_changed):
if body_not_changed:
self.body_not_changed = BodyNotChanged()
else:
self.body_not_changed = None
empty_body = property(_get_empty_body, _set_empty_body)
del _get_empty_body, _set_empty_body
class Param(XMLEmptyElement):
_xml_tag = 'param'
_xml_namespace = namespace
_xml_document = DialogInfoDocument
pname = XMLAttribute('pname', type=str, required=True, test_equal=True)
pval = XMLAttribute('pval', type=str, required=True, test_equal=True)
def __init__(self, pname, pval):
XMLEmptyElement.__init__(self)
self.pname = pname
self.pval = pval
class DialogInfo(XMLListRootElement):
content_type = "application/dialog-info+xml"
_xml_tag = 'dialog-info'
_xml_namespace = namespace
_xml_application = DialogInfoApplication
_xml_schema_file = 'dialog-info.xsd'
_xml_children_order = {Dialog.qname: 0, None: 1}
version = XMLAttribute('version',
type=VersionValue,
required=True,
test_equal=True)
state = XMLAttribute('state',
type=StateValue,
required=True,
test_equal=True)
entity = XMLAttribute('entity', type=str, required=True, test_equal=True)
def __init__(self, version, state, entity, dialogs=[]):
XMLListRootElement.__init__(self)
self.version = version
self.state = state
self.entity = entity
self[0:0] = dialogs
def _build_element(self, *args, **kwargs):
for child in self:
child.to_element(*args, **kwargs)
def _del_item(self, value):
self.element.remove(value.element)
def _parse_element(self, element, *args, **kwargs):
for child in element:
child_cls = self._xml_application.get_element(child.tag)
if child_cls is not None and (
True if child_cls is [c for c in [Dialog]] else False):
try:
list.append(self,
child_cls.from_element(child, *args, **kwargs))
except ValidationError:
pass
def _add_item(self, value):
if not isinstance(value, (Dialog)):
raise TypeError("dialog-info element can't contain %s element" %
value.__class__.__name__)
self._insert_element(value.element)
return value
class StatusIcon(XMLStringElement, ServiceExtension, PersonExtension):
_xml_tag = 'status-icon'
_xml_namespace = namespace
_xml_document = PIDFDocument
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)
def __init__(self, value=None, id=None, since=None, until=None):
XMLStringElement.__init__(self, value)
self.id = id
self.since = since
self.until = until
class Note(XMLStringElement):
_xml_tag = 'note'
_xml_namespace = pidf_namespace
_xml_application = PIDFApplication
_xml_lang = True
since = XMLAttribute('since',
xmlname='from',
type=util.Timestamp,
required=False,
test_equal=True)
until = XMLAttribute('until',
type=util.Timestamp,
required=False,
test_equal=True)
class IdentityMany(XMLListElement):
_xml_tag = 'many'
_xml_namespace = namespace
_xml_document = CommonPolicyDocument
_xml_children_order = {IdentityExcept.qname: 0}
_xml_item_type = IdentityExcept
domain = XMLAttribute('domain', type=str, required=False, test_equal=True)
def __init__(self, domain=None, exceptions=[]):
XMLListElement.__init__(self)
self.domain = domain
self.update(exceptions)
def __repr__(self):
return '%s(%r, %s)' % (self.__class__.__name__, self.domain, list(self))
def matches(self, uri):
if self.domain is not None:
if self.domain != uri.partition('@')[2]:
return False
for child in self:
if not child.matches(uri):
return False
return True
class Target(XMLListElement):
_xml_tag = 'target'
_xml_namespace = namespace
_xml_application = DialogInfoApplication
uri = XMLAttribute('uri', type=str, required=True, test_equal=True)
def __init__(self, uri, params=[]):
self.uri = uri
self[0:0] = params
def _build_element(self, *args, **kwargs):
for child in self:
child.to_element(*args, **kwargs)
def _del_item(self, value):
self.element.remove(value.element)
def _parse_element(self, element, *args, **kwargs):
for child in element:
child_cls = self._xml_application.get_element(child.tag)
if child_cls is not None and (
True if child_cls is [c for c in [Param]] else False):
try:
list.append(self,
child_cls.from_element(child, *args, **kwargs))
except ValidationError:
pass
def _add_item(self, value):
if not isinstance(value, (Param)):
raise TypeError("Target element can't contain %s element" %
value.__class__.__name__)
self._insert_element(value.element)
return value
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 Entry(XMLStringElement):
_xml_tag = 'entry'
_xml_namespace = namespace
_xml_application = XCAPDirectoryApplication
uri = XMLAttribute('uri', type=str, required=True, test_equal=True)
etag = XMLAttribute('etag', type=str, required=True, test_equal=True)
last_modified = XMLAttribute('last_modified',
xmlname='last-modified',
type=Timestamp,
required=False,
test_equal=True)
size = XMLAttribute('size',
type=SizeValue,
required=False,
test_equal=True)
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 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 ContactURIList(XMLListElement):
_xml_tag = 'uris'
_xml_namespace = namespace
_xml_document = ResourceListsDocument
_xml_item_type = ContactURI
default = XMLAttribute('default',
type=str,
required=False,
test_equal=True)
def __init__(self, uris=[], default=None):
XMLListElement.__init__(self)
self.update(uris)
self.default = default
def __getitem__(self, key):
if key is IterateIDs:
return iter(self._xmlid_map[ContactURI].keys())
elif key is IterateItems:
return iter(self._xmlid_map[ContactURI].values())
else:
return self._xmlid_map[ContactURI][key]
def __delitem__(self, key):
if key is All:
for item in list(self._xmlid_map[ContactURI].values()):
self.remove(item)
else:
self.remove(self._xmlid_map[ContactURI][key])
def get(self, key, default=None):
return self._xmlid_map[ContactURI].get(key, default)
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 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 WatcherList(XMLListElement):
"""
Definition for a list of watchers in a watcherinfo document
It behaves like a list in that it can be indexed by a number, can be
iterated and counted.
It also provides the properties pending, active and terminated which are
generators returning Watcher objects with the corresponding status.
"""
_xml_tag = 'watcher-list'
_xml_namespace = namespace
_xml_document = WatcherInfoDocument
_xml_children_order = {Watcher.qname: 0}
_xml_item_type = Watcher
resource = XMLElementID('resource',
type=SIPURI,
required=True,
test_equal=True)
package = XMLAttribute('package', type=str, required=True, test_equal=True)
def __init__(self, resource, package, watchers=[]):
XMLListElement.__init__(self)
self.resource = resource
self.package = package
self.update(watchers)
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.resource,
self.package, list(self))
def __getitem__(self, key):
if key is IterateIDs:
return self._xmlid_map[Watcher].iterkeys()
elif key is IterateItems:
return self._xmlid_map[Watcher].itervalues()
else:
return self._xmlid_map[Watcher][key]
def __delitem__(self, key):
if key is All:
for item in self._xmlid_map[Watcher].values():
self.remove(item)
else:
self.remove(self._xmlid_map[Watcher][key])
def get(self, key, default=None):
return self._xmlid_map[Watcher].get(key, default)
pending = property(lambda self: (watcher for watcher in self
if watcher.status == 'pending'))
waiting = property(lambda self: (watcher for watcher in self
if watcher.status == 'waiting'))
active = property(lambda self: (watcher for watcher in self
if watcher.status == 'active'))
terminated = property(lambda self: (watcher for watcher in self
if watcher.status == 'terminated'))
class ProvideUnknownAttribute(XMLBooleanElement,
commonpolicy.TransformationElement):
_xml_tag = 'provide-unknown-attribute'
_xml_namespace = namespace
_xml_document = PresRulesDocument
name = XMLAttribute('name', type=str, required=True, test_equal=True)
ns = XMLAttribute('ns', type=str, required=True, test_equal=True)
def __init__(self, ns, name, value):
XMLBooleanElement.__init__(self, value)
self.ns = ns
self.name = name
def __repr__(self):
return '%s(%r, %r, %r)' % (self.__class__.__name__, self.ns, self.name,
self.value)
