/usr/lib/python3/dist-packages/sleekxmpp/roster/single.py is in python3-sleekxmpp 1.3.1-6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 | """
SleekXMPP: The Sleek XMPP Library
Copyright (C) 2010 Nathanael C. Fritz
This file is part of SleekXMPP.
See the file LICENSE for copying permission.
"""
import threading
from sleekxmpp.xmlstream import JID
from sleekxmpp.roster import RosterItem
class RosterNode(object):
"""
A roster node is a roster for a single JID.
Attributes:
xmpp -- The main SleekXMPP instance.
jid -- The JID that owns the roster node.
db -- Optional interface to an external datastore.
auto_authorize -- Determines how authorizations are handled:
True -- Accept all subscriptions.
False -- Reject all subscriptions.
None -- Subscriptions must be
manually authorized.
Defaults to True.
auto_subscribe -- Determines if bi-directional subscriptions
are created after automatically authrorizing
a subscription request.
Defaults to True
last_status -- The last sent presence status that was broadcast
to all contact JIDs.
Methods:
add -- Add a JID to the roster.
update -- Update a JID's subscription information.
subscribe -- Subscribe to a JID.
unsubscribe -- Unsubscribe from a JID.
remove -- Remove a JID from the roster.
presence -- Return presence information for a JID's resources.
send_presence -- Shortcut for sending a presence stanza.
"""
def __init__(self, xmpp, jid, db=None):
"""
Create a roster node for a JID.
Arguments:
xmpp -- The main SleekXMPP instance.
jid -- The JID that owns the roster.
db -- Optional interface to an external datastore.
"""
self.xmpp = xmpp
self.jid = jid
self.db = db
self.auto_authorize = True
self.auto_subscribe = True
self.last_status = None
self._version = ''
self._jids = {}
self._last_status_lock = threading.Lock()
if self.db:
if hasattr(self.db, 'version'):
self._version = self.db.version(self.jid)
for jid in self.db.entries(self.jid):
self.add(jid)
@property
def version(self):
"""Retrieve the roster's version ID."""
if self.db and hasattr(self.db, 'version'):
self._version = self.db.version(self.jid)
return self._version
@version.setter
def version(self, version):
"""Set the roster's version ID."""
self._version = version
if self.db and hasattr(self.db, 'set_version'):
self.db.set_version(self.jid, version)
def __getitem__(self, key):
"""
Return the roster item for a subscribed JID.
A new item entry will be created if one does not already exist.
"""
if key is None:
key = JID('')
if not isinstance(key, JID):
key = JID(key)
key = key.bare
if key not in self._jids:
self.add(key, save=True)
return self._jids[key]
def __delitem__(self, key):
"""
Remove a roster item from the local storage.
To remove an item from the server, use the remove() method.
"""
if key is None:
key = JID('')
if not isinstance(key, JID):
key = JID(key)
key = key.bare
if key in self._jids:
del self._jids[key]
def __len__(self):
"""Return the number of JIDs referenced by the roster."""
return len(self._jids)
def keys(self):
"""Return a list of all subscribed JIDs."""
return self._jids.keys()
def has_jid(self, jid):
"""Returns whether the roster has a JID."""
return jid in self._jids
def groups(self):
"""Return a dictionary mapping group names to JIDs."""
result = {}
for jid in self._jids:
groups = self._jids[jid]['groups']
if not groups:
if '' not in result:
result[''] = []
result[''].append(jid)
for group in groups:
if group not in result:
result[group] = []
result[group].append(jid)
return result
def __iter__(self):
"""Iterate over the roster items."""
return self._jids.__iter__()
def set_backend(self, db=None, save=True):
"""
Set the datastore interface object for the roster node.
Arguments:
db -- The new datastore interface.
save -- If True, save the existing state to the new
backend datastore. Defaults to True.
"""
self.db = db
existing_entries = set(self._jids)
new_entries = set(self.db.entries(self.jid, {}))
for jid in existing_entries:
self._jids[jid].set_backend(db, save)
for jid in new_entries - existing_entries:
self.add(jid)
def add(self, jid, name='', groups=None, afrom=False, ato=False,
pending_in=False, pending_out=False, whitelisted=False,
save=False):
"""
Add a new roster item entry.
Arguments:
jid -- The JID for the roster item.
name -- An alias for the JID.
groups -- A list of group names.
afrom -- Indicates if the JID has a subscription state
of 'from'. Defaults to False.
ato -- Indicates if the JID has a subscription state
of 'to'. Defaults to False.
pending_in -- Indicates if the JID has sent a subscription
request to this connection's JID.
Defaults to False.
pending_out -- Indicates if a subscription request has been sent
to this JID.
Defaults to False.
whitelisted -- Indicates if a subscription request from this JID
should be automatically authorized.
Defaults to False.
save -- Indicates if the item should be persisted
immediately to an external datastore,
if one is used.
Defaults to False.
"""
if isinstance(jid, JID):
key = jid.bare
else:
key = jid
state = {'name': name,
'groups': groups or [],
'from': afrom,
'to': ato,
'pending_in': pending_in,
'pending_out': pending_out,
'whitelisted': whitelisted,
'subscription': 'none'}
self._jids[key] = RosterItem(self.xmpp, jid, self.jid,
state=state, db=self.db,
roster=self)
if save:
self._jids[key].save()
def subscribe(self, jid):
"""
Subscribe to the given JID.
Arguments:
jid -- The JID to subscribe to.
"""
self[jid].subscribe()
def unsubscribe(self, jid):
"""
Unsubscribe from the given JID.
Arguments:
jid -- The JID to unsubscribe from.
"""
self[jid].unsubscribe()
def remove(self, jid):
"""
Remove a JID from the roster.
Arguments:
jid -- The JID to remove.
"""
self[jid].remove()
if not self.xmpp.is_component:
return self.update(jid, subscription='remove')
def update(self, jid, name=None, subscription=None, groups=None, block=True, timeout=None, callback=None):
"""
Update a JID's subscription information.
Arguments:
jid -- The JID to update.
name -- Optional alias for the JID.
subscription -- The subscription state. May be one of: 'to',
'from', 'both', 'none', or 'remove'.
groups -- A list of group names.
block -- Specify if the roster request will block
until a response is received, or a timeout
occurs. Defaults to True.
timeout -- The length of time (in seconds) to wait
for a response before continuing if blocking
is used. Defaults to self.response_timeout.
callback -- Optional reference to a stream handler function.
Will be executed when the roster is received.
Implies block=False.
"""
if not groups:
groups = []
self[jid]['name'] = name
self[jid]['groups'] = groups
self[jid].save()
if not self.xmpp.is_component:
iq = self.xmpp.Iq()
iq['type'] = 'set'
iq['roster']['items'] = {jid: {'name': name,
'subscription': subscription,
'groups': groups}}
return iq.send(block, timeout, callback)
def presence(self, jid, resource=None):
"""
Retrieve the presence information of a JID.
May return either all online resources' status, or
a single resource's status.
Arguments:
jid -- The JID to lookup.
resource -- Optional resource for returning
only the status of a single connection.
"""
if resource is None:
return self[jid].resources
default_presence = {'status': '',
'priority': 0,
'show': ''}
return self[jid].resources.get(resource,
default_presence)
def reset(self):
"""
Reset the state of the roster to forget any current
presence information. Useful after a disconnection occurs.
"""
for jid in self:
self[jid].reset()
def send_presence(self, **kwargs):
"""
Create, initialize, and send a Presence stanza.
If no recipient is specified, send the presence immediately.
Otherwise, forward the send request to the recipient's roster
entry for processing.
Arguments:
pshow -- The presence's show value.
pstatus -- The presence's status message.
ppriority -- This connections' priority.
pto -- The recipient of a directed presence.
pfrom -- The sender of a directed presence, which should
be the owner JID plus resource.
ptype -- The type of presence, such as 'subscribe'.
pnick -- Optional nickname of the presence's sender.
"""
if self.xmpp.is_component and not kwargs.get('pfrom', ''):
kwargs['pfrom'] = self.jid
self.xmpp.send_presence(**kwargs)
def send_last_presence(self):
if self.last_status is None:
self.send_presence()
else:
pres = self.last_status
if self.xmpp.is_component:
pres['from'] = self.jid
else:
del pres['from']
pres.send()
def __repr__(self):
return repr(self._jids)
|