_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q259500 | beat_position | validation | def beat_position(annotation, **kwargs):
'''Plotting wrapper for beat-position data'''
times, values = annotation.to_interval_values()
labels = [_['position'] for _ in values]
# TODO: plot time signature, measure number
return mir_eval.display.events(times, labels=labels, **kwargs) | python | {
"resource": ""
} |
q259501 | piano_roll | validation | def piano_roll(annotation, **kwargs):
'''Plotting wrapper for piano rolls'''
times, midi = annotation.to_interval_values()
return mir_eval.display.piano_roll(times, midi=midi, **kwargs) | python | {
"resource": ""
} |
q259502 | display | validation | def display(annotation, meta=True, **kwargs):
'''Visualize a jams annotation through mir_eval
Parameters
----------
annotation : jams.Annotation
The annotation to display
meta : bool
If `True`, include annotation metadata in the figure
kwargs
Additional keyword arguments to mir_eval.display functions
Returns
-------
ax
Axis handles for the new display
Raises
------
NamespaceError
If the annotation cannot be visualized
'''
for namespace, func in six.iteritems(VIZ_MAPPING):
try:
ann = coerce_annotation(annotation, namespace)
axes = func(ann, **kwargs)
# Title should correspond to original namespace, not the coerced version
axes.set_title(annotation.namespace)
if meta:
description = pprint_jobject(annotation.annotation_metadata, indent=2)
anchored_box = AnchoredText(description.strip('\n'),
loc=2,
frameon=True,
bbox_to_anchor=(1.02, 1.0),
bbox_transform=axes.transAxes,
borderpad=0.0)
axes.add_artist(anchored_box)
axes.figure.subplots_adjust(right=0.8)
return axes
except NamespaceError:
pass
raise NamespaceError('Unable to visualize annotation of namespace="{:s}"'
.format(annotation.namespace)) | python | {
"resource": ""
} |
q259503 | display_multi | validation | def display_multi(annotations, fig_kw=None, meta=True, **kwargs):
'''Display multiple annotations with shared axes
Parameters
----------
annotations : jams.AnnotationArray
A collection of annotations to display
fig_kw : dict
Keyword arguments to `plt.figure`
meta : bool
If `True`, display annotation metadata for each annotation
kwargs
Additional keyword arguments to the `mir_eval.display` routines
Returns
-------
fig
The created figure
axs
List of subplot axes corresponding to each displayed annotation
'''
if fig_kw is None:
fig_kw = dict()
fig_kw.setdefault('sharex', True)
fig_kw.setdefault('squeeze', True)
# Filter down to coercable annotations first
display_annotations = []
for ann in annotations:
for namespace in VIZ_MAPPING:
if can_convert(ann, namespace):
display_annotations.append(ann)
break
# If there are no displayable annotations, fail here
if not len(display_annotations):
raise ParameterError('No displayable annotations found')
fig, axs = plt.subplots(nrows=len(display_annotations), ncols=1, **fig_kw)
# MPL is stupid when making singleton subplots.
# We catch this and make it always iterable.
if len(display_annotations) == 1:
axs = [axs]
for ann, ax in zip(display_annotations, axs):
kwargs['ax'] = ax
display(ann, meta=meta, **kwargs)
return fig, axs | python | {
"resource": ""
} |
q259504 | mkclick | validation | def mkclick(freq, sr=22050, duration=0.1):
'''Generate a click sample.
This replicates functionality from mir_eval.sonify.clicks,
but exposes the target frequency and duration.
'''
times = np.arange(int(sr * duration))
click = np.sin(2 * np.pi * times * freq / float(sr))
click *= np.exp(- times / (1e-2 * sr))
return click | python | {
"resource": ""
} |
q259505 | clicks | validation | def clicks(annotation, sr=22050, length=None, **kwargs):
'''Sonify events with clicks.
This uses mir_eval.sonify.clicks, and is appropriate for instantaneous
events such as beats or segment boundaries.
'''
interval, _ = annotation.to_interval_values()
return filter_kwargs(mir_eval.sonify.clicks, interval[:, 0],
fs=sr, length=length, **kwargs) | python | {
"resource": ""
} |
q259506 | downbeat | validation | def downbeat(annotation, sr=22050, length=None, **kwargs):
'''Sonify beats and downbeats together.
'''
beat_click = mkclick(440 * 2, sr=sr)
downbeat_click = mkclick(440 * 3, sr=sr)
intervals, values = annotation.to_interval_values()
beats, downbeats = [], []
for time, value in zip(intervals[:, 0], values):
if value['position'] == 1:
downbeats.append(time)
else:
beats.append(time)
if length is None:
length = int(sr * np.max(intervals)) + len(beat_click) + 1
y = filter_kwargs(mir_eval.sonify.clicks,
np.asarray(beats),
fs=sr, length=length, click=beat_click)
y += filter_kwargs(mir_eval.sonify.clicks,
np.asarray(downbeats),
fs=sr, length=length, click=downbeat_click)
return y | python | {
"resource": ""
} |
q259507 | multi_segment | validation | def multi_segment(annotation, sr=22050, length=None, **kwargs):
'''Sonify multi-level segmentations'''
# Pentatonic scale, because why not
PENT = [1, 32./27, 4./3, 3./2, 16./9]
DURATION = 0.1
h_int, _ = hierarchy_flatten(annotation)
if length is None:
length = int(sr * (max(np.max(_) for _ in h_int) + 1. / DURATION) + 1)
y = 0.0
for ints, (oc, scale) in zip(h_int, product(range(3, 3 + len(h_int)),
PENT)):
click = mkclick(440.0 * scale * oc, sr=sr, duration=DURATION)
y = y + filter_kwargs(mir_eval.sonify.clicks,
np.unique(ints),
fs=sr, length=length,
click=click)
return y | python | {
"resource": ""
} |
q259508 | pitch_contour | validation | def pitch_contour(annotation, sr=22050, length=None, **kwargs):
'''Sonify pitch contours.
This uses mir_eval.sonify.pitch_contour, and should only be applied
to pitch annotations using the pitch_contour namespace.
Each contour is sonified independently, and the resulting waveforms
are summed together.
'''
# Map contours to lists of observations
times = defaultdict(list)
freqs = defaultdict(list)
for obs in annotation:
times[obs.value['index']].append(obs.time)
freqs[obs.value['index']].append(obs.value['frequency'] *
(-1)**(~obs.value['voiced']))
y_out = 0.0
for ix in times:
y_out = y_out + filter_kwargs(mir_eval.sonify.pitch_contour,
np.asarray(times[ix]),
np.asarray(freqs[ix]),
fs=sr, length=length,
**kwargs)
if length is None:
length = len(y_out)
return y_out | python | {
"resource": ""
} |
q259509 | piano_roll | validation | def piano_roll(annotation, sr=22050, length=None, **kwargs):
'''Sonify a piano-roll
This uses mir_eval.sonify.time_frequency, and is appropriate
for sparse transcription data, e.g., annotations in the `note_midi`
namespace.
'''
intervals, pitches = annotation.to_interval_values()
# Construct the pitchogram
pitch_map = {f: idx for idx, f in enumerate(np.unique(pitches))}
gram = np.zeros((len(pitch_map), len(intervals)))
for col, f in enumerate(pitches):
gram[pitch_map[f], col] = 1
return filter_kwargs(mir_eval.sonify.time_frequency,
gram, pitches, intervals,
sr, length=length, **kwargs) | python | {
"resource": ""
} |
q259510 | sonify | validation | def sonify(annotation, sr=22050, duration=None, **kwargs):
'''Sonify a jams annotation through mir_eval
Parameters
----------
annotation : jams.Annotation
The annotation to sonify
sr = : positive number
The sampling rate of the output waveform
duration : float (optional)
Optional length (in seconds) of the output waveform
kwargs
Additional keyword arguments to mir_eval.sonify functions
Returns
-------
y_sonified : np.ndarray
The waveform of the sonified annotation
Raises
------
NamespaceError
If the annotation has an un-sonifiable namespace
'''
length = None
if duration is None:
duration = annotation.duration
if duration is not None:
length = int(duration * sr)
# If the annotation can be directly sonified, try that first
if annotation.namespace in SONIFY_MAPPING:
ann = coerce_annotation(annotation, annotation.namespace)
return SONIFY_MAPPING[annotation.namespace](ann,
sr=sr,
length=length,
**kwargs)
for namespace, func in six.iteritems(SONIFY_MAPPING):
try:
ann = coerce_annotation(annotation, namespace)
return func(ann, sr=sr, length=length, **kwargs)
except NamespaceError:
pass
raise NamespaceError('Unable to sonify annotation of namespace="{:s}"'
.format(annotation.namespace)) | python | {
"resource": ""
} |
q259511 | validate | validation | def validate(schema_file=None, jams_files=None):
'''Validate a jams file against a schema'''
schema = load_json(schema_file)
for jams_file in jams_files:
try:
jams = load_json(jams_file)
jsonschema.validate(jams, schema)
print '{:s} was successfully validated'.format(jams_file)
except jsonschema.ValidationError as exc:
print '{:s} was NOT successfully validated'.format(jams_file)
print exc | python | {
"resource": ""
} |
q259512 | StreamSASLHandler._handle_auth_success | validation | def _handle_auth_success(self, stream, success):
"""Handle successful authentication.
Send <success/> and mark the stream peer authenticated.
[receiver only]
"""
if not self._check_authorization(success.properties, stream):
element = ElementTree.Element(FAILURE_TAG)
ElementTree.SubElement(element, SASL_QNP + "invalid-authzid")
return True
authzid = success.properties.get("authzid")
if authzid:
peer = JID(success.authzid)
elif "username" in success.properties:
peer = JID(success.properties["username"], stream.me.domain)
else:
# anonymous
peer = None
stream.set_peer_authenticated(peer, True) | python | {
"resource": ""
} |
q259513 | StreamSASLHandler._check_authorization | validation | def _check_authorization(self, properties, stream):
"""Check authorization id and other properties returned by the
authentication mechanism.
[receiving entity only]
Allow only no authzid or authzid equal to current username@domain
FIXME: other rules in s2s
:Parameters:
- `properties`: data obtained during authentication
:Types:
- `properties`: mapping
:return: `True` if user is authorized to use a provided authzid
:returntype: `bool`
"""
authzid = properties.get("authzid")
if not authzid:
return True
try:
jid = JID(authzid)
except ValueError:
return False
if "username" not in properties:
result = False
elif jid.local != properties["username"]:
result = False
elif jid.domain != stream.me.domain:
result = False
elif jid.resource:
result = False
else:
result = True
return result | python | {
"resource": ""
} |
q259514 | StreamSASLHandler._sasl_authenticate | validation | def _sasl_authenticate(self, stream, username, authzid):
"""Start SASL authentication process.
[initiating entity only]
:Parameters:
- `username`: user name.
- `authzid`: authorization ID.
- `mechanism`: SASL mechanism to use."""
if not stream.initiator:
raise SASLAuthenticationFailed("Only initiating entity start"
" SASL authentication")
if stream.features is None or not self.peer_sasl_mechanisms:
raise SASLNotAvailable("Peer doesn't support SASL")
props = dict(stream.auth_properties)
if not props.get("service-domain") and (
stream.peer and stream.peer.domain):
props["service-domain"] = stream.peer.domain
if username is not None:
props["username"] = username
if authzid is not None:
props["authzid"] = authzid
if "password" in self.settings:
props["password"] = self.settings["password"]
props["available_mechanisms"] = self.peer_sasl_mechanisms
enabled = sasl.filter_mechanism_list(
self.settings['sasl_mechanisms'], props,
self.settings['insecure_auth'])
if not enabled:
raise SASLNotAvailable(
"None of SASL mechanism selected can be used")
props["enabled_mechanisms"] = enabled
mechanism = None
for mech in enabled:
if mech in self.peer_sasl_mechanisms:
mechanism = mech
break
if not mechanism:
raise SASLMechanismNotAvailable("Peer doesn't support any of"
" our SASL mechanisms")
logger.debug("Our mechanism: {0!r}".format(mechanism))
stream.auth_method_used = mechanism
self.authenticator = sasl.client_authenticator_factory(mechanism)
initial_response = self.authenticator.start(props)
if not isinstance(initial_response, sasl.Response):
raise SASLAuthenticationFailed("SASL initiation failed")
element = ElementTree.Element(AUTH_TAG)
element.set("mechanism", mechanism)
if initial_response.data:
if initial_response.encode:
element.text = initial_response.encode()
else:
element.text = initial_response.data
stream.write_element(element) | python | {
"resource": ""
} |
q259515 | timeout_handler | validation | def timeout_handler(interval, recurring = None):
"""Method decorator generator for decorating event handlers.
To be used on `TimeoutHandler` subclass methods only.
:Parameters:
- `interval`: interval (in seconds) before the method will be called.
- `recurring`: When `True`, the handler will be called each `interval`
seconds, when `False` it will be called only once. If `True`,
then the handler should return the next interval or `None` if it
should not be called again.
:Types:
- `interval`: `float`
- `recurring`: `bool`
"""
def decorator(func):
"""The decorator"""
func._pyxmpp_timeout = interval
func._pyxmpp_recurring = recurring
return func
return decorator | python | {
"resource": ""
} |
q259516 | MainLoop.delayed_call | validation | def delayed_call(self, delay, function):
"""Schedule function to be called from the main loop after `delay`
seconds.
:Parameters:
- `delay`: seconds to wait
:Types:
- `delay`: `float`
"""
main_loop = self
handler = []
class DelayedCallHandler(TimeoutHandler):
"""Wrapper timeout handler class for the delayed call."""
# pylint: disable=R0903
@timeout_handler(delay, False)
def callback(self):
"""Wrapper timeout handler method for the delayed call."""
try:
function()
finally:
main_loop.remove_handler(handler[0])
handler.append(DelayedCallHandler())
self.add_handler(handler[0]) | python | {
"resource": ""
} |
q259517 | RosterItem.from_xml | validation | def from_xml(cls, element):
"""Make a RosterItem from an XML element.
:Parameters:
- `element`: the XML element
:Types:
- `element`: :etree:`ElementTree.Element`
:return: a freshly created roster item
:returntype: `cls`
"""
if element.tag != ITEM_TAG:
raise ValueError("{0!r} is not a roster item".format(element))
try:
jid = JID(element.get("jid"))
except ValueError:
raise BadRequestProtocolError(u"Bad item JID")
subscription = element.get("subscription")
ask = element.get("ask")
name = element.get("name")
duplicate_group = False
groups = set()
for child in element:
if child.tag != GROUP_TAG:
continue
group = child.text
if group is None:
group = u""
if group in groups:
duplicate_group = True
else:
groups.add(group)
approved = element.get("approved")
if approved == "true":
approved = True
elif approved in ("false", None):
approved = False
else:
logger.debug("RosterItem.from_xml: got unknown 'approved':"
" {0!r}, changing to False".format(approved))
approved = False
result = cls(jid, name, groups, subscription, ask, approved)
result._duplicate_group = duplicate_group
return result | python | {
"resource": ""
} |
q259518 | RosterItem.as_xml | validation | def as_xml(self, parent = None):
"""Make an XML element from self.
:Parameters:
- `parent`: Parent element
:Types:
- `parent`: :etree:`ElementTree.Element`
"""
if parent is not None:
element = ElementTree.SubElement(parent, ITEM_TAG)
else:
element = ElementTree.Element(ITEM_TAG)
element.set("jid", unicode(self.jid))
if self.name is not None:
element.set("name", self.name)
if self.subscription is not None:
element.set("subscription", self.subscription)
if self.ask:
element.set("ask", self.ask)
if self.approved:
element.set("approved", "true")
for group in self.groups:
ElementTree.SubElement(element, GROUP_TAG).text = group
return element | python | {
"resource": ""
} |
q259519 | RosterItem.verify_roster_push | validation | def verify_roster_push(self, fix = False):
"""Check if `self` is valid roster push item.
Valid item must have proper `subscription` value other and valid value
for 'ask'.
:Parameters:
- `fix`: if `True` than replace invalid 'subscription' and 'ask'
values with the defaults
:Types:
- `fix`: `bool`
:Raise: `ValueError` if the item is invalid.
"""
self._verify((None, u"from", u"to", u"both", u"remove"), fix) | python | {
"resource": ""
} |
q259520 | RosterItem.verify_roster_set | validation | def verify_roster_set(self, fix = False, settings = None):
"""Check if `self` is valid roster set item.
For use on server to validate incoming roster sets.
Valid item must have proper `subscription` value other and valid value
for 'ask'. The lengths of name and group names must fit the configured
limits.
:Parameters:
- `fix`: if `True` than replace invalid 'subscription' and 'ask'
values with right defaults
- `settings`: settings object providing the name limits
:Types:
- `fix`: `bool`
- `settings`: `XMPPSettings`
:Raise: `BadRequestProtocolError` if the item is invalid.
"""
# pylint: disable=R0912
try:
self._verify((None, u"remove"), fix)
except ValueError, err:
raise BadRequestProtocolError(unicode(err))
if self.ask:
if fix:
self.ask = None
else:
raise BadRequestProtocolError("'ask' in roster set")
if self.approved:
if fix:
self.approved = False
else:
raise BadRequestProtocolError("'approved' in roster set")
if settings is None:
settings = XMPPSettings()
name_length_limit = settings["roster_name_length_limit"]
if self.name and len(self.name) > name_length_limit:
raise NotAcceptableProtocolError(u"Roster item name too long")
group_length_limit = settings["roster_group_name_length_limit"]
for group in self.groups:
if not group:
raise NotAcceptableProtocolError(u"Roster group name empty")
if len(group) > group_length_limit:
raise NotAcceptableProtocolError(u"Roster group name too long")
if self._duplicate_group:
raise BadRequestProtocolError(u"Item group duplicated") | python | {
"resource": ""
} |
q259521 | Roster.groups | validation | def groups(self):
"""Set of groups defined in the roster.
:Return: the groups
:ReturnType: `set` of `unicode`
"""
groups = set()
for item in self._items:
groups |= item.groups
return groups | python | {
"resource": ""
} |
q259522 | Roster.get_items_by_name | validation | def get_items_by_name(self, name, case_sensitive = True):
"""
Return a list of items with given name.
:Parameters:
- `name`: name to look-up
- `case_sensitive`: if `False` the matching will be case
insensitive.
:Types:
- `name`: `unicode`
- `case_sensitive`: `bool`
:Returntype: `list` of `RosterItem`
"""
if not case_sensitive and name:
name = name.lower()
result = []
for item in self._items:
if item.name == name:
result.append(item)
elif item.name is None:
continue
elif not case_sensitive and item.name.lower() == name:
result.append(item)
return result | python | {
"resource": ""
} |
q259523 | Roster.get_items_by_group | validation | def get_items_by_group(self, group, case_sensitive = True):
"""
Return a list of items within a given group.
:Parameters:
- `name`: name to look-up
- `case_sensitive`: if `False` the matching will be case
insensitive.
:Types:
- `name`: `unicode`
- `case_sensitive`: `bool`
:Returntype: `list` of `RosterItem`
"""
result = []
if not group:
for item in self._items:
if not item.groups:
result.append(item)
return result
if not case_sensitive:
group = group.lower()
for item in self._items:
if group in item.groups:
result.append(item)
elif not case_sensitive and group in [g.lower() for g
in item.groups]:
result.append(item)
return result | python | {
"resource": ""
} |
q259524 | Roster.add_item | validation | def add_item(self, item, replace = False):
"""
Add an item to the roster.
This will not automatically update the roster on the server.
:Parameters:
- `item`: the item to add
- `replace`: if `True` then existing item will be replaced,
otherwise a `ValueError` will be raised on conflict
:Types:
- `item`: `RosterItem`
- `replace`: `bool`
"""
if item.jid in self._jids:
if replace:
self.remove_item(item.jid)
else:
raise ValueError("JID already in the roster")
index = len(self._items)
self._items.append(item)
self._jids[item.jid] = index | python | {
"resource": ""
} |
q259525 | Roster.remove_item | validation | def remove_item(self, jid):
"""Remove item from the roster.
:Parameters:
- `jid`: JID of the item to remove
:Types:
- `jid`: `JID`
"""
if jid not in self._jids:
raise KeyError(jid)
index = self._jids[jid]
for i in range(index, len(self._jids)):
self._jids[self._items[i].jid] -= 1
del self._jids[jid]
del self._items[index] | python | {
"resource": ""
} |
q259526 | RosterClient.load_roster | validation | def load_roster(self, source):
"""Load roster from an XML file.
Can be used before the connection is started to load saved
roster copy, for efficient retrieval of versioned roster.
:Parameters:
- `source`: file name or a file object
:Types:
- `source`: `str` or file-like object
"""
try:
tree = ElementTree.parse(source)
except ElementTree.ParseError, err:
raise ValueError("Invalid roster format: {0}".format(err))
roster = Roster.from_xml(tree.getroot())
for item in roster:
item.verify_roster_result(True)
self.roster = roster | python | {
"resource": ""
} |
q259527 | RosterClient.save_roster | validation | def save_roster(self, dest, pretty = True):
"""Save the roster to an XML file.
Can be used to save the last know roster copy for faster loading
of a verisoned roster (if server supports that).
:Parameters:
- `dest`: file name or a file object
- `pretty`: pretty-format the roster XML
:Types:
- `dest`: `str` or file-like object
- `pretty`: `bool`
"""
if self.roster is None:
raise ValueError("No roster")
element = self.roster.as_xml()
if pretty:
if len(element):
element.text = u'\n '
p_child = None
for child in element:
if p_child is not None:
p_child.tail = u'\n '
if len(child):
child.text = u'\n '
p_grand = None
for grand in child:
if p_grand is not None:
p_grand.tail = u'\n '
p_grand = grand
if p_grand is not None:
p_grand.tail = u'\n '
p_child = child
if p_child is not None:
p_child.tail = u"\n"
tree = ElementTree.ElementTree(element)
tree.write(dest, "utf-8") | python | {
"resource": ""
} |
q259528 | RosterClient.handle_got_features_event | validation | def handle_got_features_event(self, event):
"""Check for roster related features in the stream features received
and set `server_features` accordingly.
"""
server_features = set()
logger.debug("Checking roster-related features")
if event.features.find(FEATURE_ROSTERVER) is not None:
logger.debug(" Roster versioning available")
server_features.add("versioning")
if event.features.find(FEATURE_APPROVALS) is not None:
logger.debug(" Subscription pre-approvals available")
server_features.add("pre-approvals")
self.server_features = server_features | python | {
"resource": ""
} |
q259529 | RosterClient.handle_authorized_event | validation | def handle_authorized_event(self, event):
"""Request roster upon login."""
self.server = event.authorized_jid.bare()
if "versioning" in self.server_features:
if self.roster is not None and self.roster.version is not None:
version = self.roster.version
else:
version = u""
else:
version = None
self.request_roster(version) | python | {
"resource": ""
} |
q259530 | RosterClient.request_roster | validation | def request_roster(self, version = None):
"""Request roster from server.
:Parameters:
- `version`: if not `None` versioned roster will be requested
for given local version. Use "" to request full roster.
:Types:
- `version`: `unicode`
"""
processor = self.stanza_processor
request = Iq(stanza_type = "get")
request.set_payload(RosterPayload(version = version))
processor.set_response_handlers(request,
self._get_success, self._get_error)
processor.send(request) | python | {
"resource": ""
} |
q259531 | RosterClient._get_success | validation | def _get_success(self, stanza):
"""Handle successful response to the roster request.
"""
payload = stanza.get_payload(RosterPayload)
if payload is None:
if "versioning" in self.server_features and self.roster:
logger.debug("Server will send roster delta in pushes")
else:
logger.warning("Bad roster response (no payload)")
self._event_queue.put(RosterNotReceivedEvent(self, stanza))
return
else:
items = list(payload)
for item in items:
item.verify_roster_result(True)
self.roster = Roster(items, payload.version)
self._event_queue.put(RosterReceivedEvent(self, self.roster)) | python | {
"resource": ""
} |
q259532 | RosterClient._get_error | validation | def _get_error(self, stanza):
"""Handle failure of the roster request.
"""
if stanza:
logger.debug(u"Roster request failed: {0}".format(
stanza.error.condition_name))
else:
logger.debug(u"Roster request failed: timeout")
self._event_queue.put(RosterNotReceivedEvent(self, stanza)) | python | {
"resource": ""
} |
q259533 | RosterClient.handle_roster_push | validation | def handle_roster_push(self, stanza):
"""Handle a roster push received from server.
"""
if self.server is None and stanza.from_jid:
logger.debug(u"Server address not known, cannot verify roster push"
" from {0}".format(stanza.from_jid))
return stanza.make_error_response(u"service-unavailable")
if self.server and stanza.from_jid and stanza.from_jid != self.server:
logger.debug(u"Roster push from invalid source: {0}".format(
stanza.from_jid))
return stanza.make_error_response(u"service-unavailable")
payload = stanza.get_payload(RosterPayload)
if len(payload) != 1:
logger.warning("Bad roster push received ({0} items)"
.format(len(payload)))
return stanza.make_error_response(u"bad-request")
if self.roster is None:
logger.debug("Dropping roster push - no roster here")
return True
item = payload[0]
item.verify_roster_push(True)
old_item = self.roster.get(item.jid)
if item.subscription == "remove":
if old_item:
self.roster.remove_item(item.jid)
else:
self.roster.add_item(item, replace = True)
self._event_queue.put(RosterUpdatedEvent(self, old_item, item))
return stanza.make_result_response() | python | {
"resource": ""
} |
q259534 | RosterClient.add_item | validation | def add_item(self, jid, name = None, groups = None,
callback = None, error_callback = None):
"""Add a contact to the roster.
:Parameters:
- `jid`: contact's jid
- `name`: name for the contact
- `groups`: sequence of group names the contact should belong to
- `callback`: function to call when the request succeeds. It should
accept a single argument - a `RosterItem` describing the
requested change
- `error_callback`: function to call when the request fails. It
should accept a single argument - an error stanza received
(`None` in case of timeout)
:Types:
- `jid`: `JID`
- `name`: `unicode`
- `groups`: sequence of `unicode`
"""
# pylint: disable=R0913
if jid in self.roster:
raise ValueError("{0!r} already in the roster".format(jid))
item = RosterItem(jid, name, groups)
self._roster_set(item, callback, error_callback) | python | {
"resource": ""
} |
q259535 | RosterClient.update_item | validation | def update_item(self, jid, name = NO_CHANGE, groups = NO_CHANGE,
callback = None, error_callback = None):
"""Modify a contact in the roster.
:Parameters:
- `jid`: contact's jid
- `name`: a new name for the contact
- `groups`: a sequence of group names the contact should belong to
- `callback`: function to call when the request succeeds. It should
accept a single argument - a `RosterItem` describing the
requested change
- `error_callback`: function to call when the request fails. It
should accept a single argument - an error stanza received
(`None` in case of timeout)
:Types:
- `jid`: `JID`
- `name`: `unicode`
- `groups`: sequence of `unicode`
"""
# pylint: disable=R0913
item = self.roster[jid]
if name is NO_CHANGE and groups is NO_CHANGE:
return
if name is NO_CHANGE:
name = item.name
if groups is NO_CHANGE:
groups = item.groups
item = RosterItem(jid, name, groups)
self._roster_set(item, callback, error_callback) | python | {
"resource": ""
} |
q259536 | RosterClient.remove_item | validation | def remove_item(self, jid, callback = None, error_callback = None):
"""Remove a contact from the roster.
:Parameters:
- `jid`: contact's jid
- `callback`: function to call when the request succeeds. It should
accept a single argument - a `RosterItem` describing the
requested change
- `error_callback`: function to call when the request fails. It
should accept a single argument - an error stanza received
(`None` in case of timeout)
:Types:
- `jid`: `JID`
"""
item = self.roster[jid]
if jid not in self.roster:
raise KeyError(jid)
item = RosterItem(jid, subscription = "remove")
self._roster_set(item, callback, error_callback) | python | {
"resource": ""
} |
q259537 | RosterClient._roster_set | validation | def _roster_set(self, item, callback, error_callback):
"""Send a 'roster set' to the server.
:Parameters:
- `item`: the requested change
:Types:
- `item`: `RosterItem`
"""
stanza = Iq(to_jid = self.server, stanza_type = "set")
payload = RosterPayload([item])
stanza.set_payload(payload)
def success_cb(result_stanza):
"""Success callback for roster set."""
if callback:
callback(item)
def error_cb(error_stanza):
"""Error callback for roster set."""
if error_callback:
error_callback(error_stanza)
else:
logger.error("Roster change of '{0}' failed".format(item.jid))
processor = self.stanza_processor
processor.set_response_handlers(stanza,
success_cb, error_cb)
processor.send(stanza) | python | {
"resource": ""
} |
q259538 | MucXBase.free | validation | def free(self):
"""
Unlink and free the XML node owned by `self`.
"""
if not self.borrowed:
self.xmlnode.unlinkNode()
self.xmlnode.freeNode()
self.xmlnode=None | python | {
"resource": ""
} |
q259539 | MucXBase.xpath_eval | validation | def xpath_eval(self,expr):
"""
Evaluate XPath expression in context of `self.xmlnode`.
:Parameters:
- `expr`: the XPath expression
:Types:
- `expr`: `unicode`
:return: the result of the expression evaluation.
:returntype: list of `libxml2.xmlNode`
"""
ctxt = common_doc.xpathNewContext()
ctxt.setContextNode(self.xmlnode)
ctxt.xpathRegisterNs("muc",self.ns.getContent())
ret=ctxt.xpathEval(to_utf8(expr))
ctxt.xpathFreeContext()
return ret | python | {
"resource": ""
} |
q259540 | MucX.set_history | validation | def set_history(self, parameters):
"""
Set history parameters.
Types:
- `parameters`: `HistoryParameters`
"""
for child in xml_element_iter(self.xmlnode.children):
if get_node_ns_uri(child) == MUC_NS and child.name == "history":
child.unlinkNode()
child.freeNode()
break
if parameters.maxchars and parameters.maxchars < 0:
raise ValueError("History parameter maxchars must be positive")
if parameters.maxstanzas and parameters.maxstanzas < 0:
raise ValueError("History parameter maxstanzas must be positive")
if parameters.maxseconds and parameters.maxseconds < 0:
raise ValueError("History parameter maxseconds must be positive")
hnode=self.xmlnode.newChild(self.xmlnode.ns(), "history", None)
if parameters.maxchars is not None:
hnode.setProp("maxchars", str(parameters.maxchars))
if parameters.maxstanzas is not None:
hnode.setProp("maxstanzas", str(parameters.maxstanzas))
if parameters.maxseconds is not None:
hnode.setProp("maxseconds", str(parameters.maxseconds))
if parameters.since is not None:
hnode.setProp("since", parameters.since.strftime("%Y-%m-%dT%H:%M:%SZ")) | python | {
"resource": ""
} |
q259541 | MucX.get_history | validation | def get_history(self):
"""Return history parameters carried by the stanza.
:returntype: `HistoryParameters`"""
for child in xml_element_iter(self.xmlnode.children):
if get_node_ns_uri(child) == MUC_NS and child.name == "history":
maxchars = from_utf8(child.prop("maxchars"))
if maxchars is not None:
maxchars = int(maxchars)
maxstanzas = from_utf8(child.prop("maxstanzas"))
if maxstanzas is not None:
maxstanzas = int(maxstanzas)
maxseconds = from_utf8(child.prop("maxseconds"))
if maxseconds is not None:
maxseconds = int(maxseconds)
# TODO: since -- requires parsing of Jabber dateTime profile
since = None
return HistoryParameters(maxchars, maxstanzas, maxseconds, since) | python | {
"resource": ""
} |
q259542 | MucX.set_password | validation | def set_password(self, password):
"""Set password for the MUC request.
:Parameters:
- `password`: password
:Types:
- `password`: `unicode`"""
for child in xml_element_iter(self.xmlnode.children):
if get_node_ns_uri(child) == MUC_NS and child.name == "password":
child.unlinkNode()
child.freeNode()
break
if password is not None:
self.xmlnode.newTextChild(self.xmlnode.ns(), "password", to_utf8(password)) | python | {
"resource": ""
} |
q259543 | MucX.get_password | validation | def get_password(self):
"""Get password from the MUC request.
:returntype: `unicode`
"""
for child in xml_element_iter(self.xmlnode.children):
if get_node_ns_uri(child) == MUC_NS and child.name == "password":
return from_utf8(child.getContent())
return None | python | {
"resource": ""
} |
q259544 | MucItem.__init | validation | def __init(self,affiliation,role,jid=None,nick=None,actor=None,reason=None):
"""Initialize a `MucItem` object from a set of attributes.
:Parameters:
- `affiliation`: affiliation of the user.
- `role`: role of the user.
- `jid`: JID of the user.
- `nick`: nickname of the user.
- `actor`: actor modyfying the user data.
- `reason`: reason of change of the user data.
:Types:
- `affiliation`: `str`
- `role`: `str`
- `jid`: `JID`
- `nick`: `unicode`
- `actor`: `JID`
- `reason`: `unicode`
"""
if not affiliation:
affiliation=None
elif affiliation not in affiliations:
raise ValueError("Bad affiliation")
self.affiliation=affiliation
if not role:
role=None
elif role not in roles:
raise ValueError("Bad role")
self.role=role
if jid:
self.jid=JID(jid)
else:
self.jid=None
if actor:
self.actor=JID(actor)
else:
self.actor=None
self.nick=nick
self.reason=reason | python | {
"resource": ""
} |
q259545 | MucItem.__from_xmlnode | validation | def __from_xmlnode(self, xmlnode):
"""Initialize a `MucItem` object from an XML node.
:Parameters:
- `xmlnode`: the XML node.
:Types:
- `xmlnode`: `libxml2.xmlNode`
"""
actor=None
reason=None
n=xmlnode.children
while n:
ns=n.ns()
if ns and ns.getContent()!=MUC_USER_NS:
continue
if n.name=="actor":
actor=n.getContent()
if n.name=="reason":
reason=n.getContent()
n=n.next
self.__init(
from_utf8(xmlnode.prop("affiliation")),
from_utf8(xmlnode.prop("role")),
from_utf8(xmlnode.prop("jid")),
from_utf8(xmlnode.prop("nick")),
from_utf8(actor),
from_utf8(reason),
); | python | {
"resource": ""
} |
q259546 | MucStatus.__init | validation | def __init(self,code):
"""Initialize a `MucStatus` element from a status code.
:Parameters:
- `code`: the status code.
:Types:
- `code`: `int`
"""
code=int(code)
if code<0 or code>999:
raise ValueError("Bad status code")
self.code=code | python | {
"resource": ""
} |
q259547 | MucUserX.get_items | validation | def get_items(self):
"""Get a list of objects describing the content of `self`.
:return: the list of objects.
:returntype: `list` of `MucItemBase` (`MucItem` and/or `MucStatus`)
"""
if not self.xmlnode.children:
return []
ret=[]
n=self.xmlnode.children
while n:
ns=n.ns()
if ns and ns.getContent()!=self.ns:
pass
elif n.name=="item":
ret.append(MucItem(n))
elif n.name=="status":
ret.append(MucStatus(n))
# FIXME: alt,decline,invite,password
n=n.next
return ret | python | {
"resource": ""
} |
q259548 | MucUserX.add_item | validation | def add_item(self,item):
"""Add an item to `self`.
:Parameters:
- `item`: the item to add.
:Types:
- `item`: `MucItemBase`
"""
if not isinstance(item,MucItemBase):
raise TypeError("Bad item type for muc#user")
item.as_xml(self.xmlnode) | python | {
"resource": ""
} |
q259549 | MucStanzaExt.get_muc_child | validation | def get_muc_child(self):
"""
Get the MUC specific payload element.
:return: the object describing the stanza payload in MUC namespace.
:returntype: `MucX` or `MucUserX` or `MucAdminQuery` or `MucOwnerX`
"""
if self.muc_child:
return self.muc_child
if not self.xmlnode.children:
return None
n=self.xmlnode.children
while n:
if n.name not in ("x","query"):
n=n.next
continue
ns=n.ns()
if not ns:
n=n.next
continue
ns_uri=ns.getContent()
if (n.name,ns_uri)==("x",MUC_NS):
self.muc_child=MucX(n)
return self.muc_child
if (n.name,ns_uri)==("x",MUC_USER_NS):
self.muc_child=MucUserX(n)
return self.muc_child
if (n.name,ns_uri)==("query",MUC_ADMIN_NS):
self.muc_child=MucAdminQuery(n)
return self.muc_child
if (n.name,ns_uri)==("query",MUC_OWNER_NS):
self.muc_child=MucOwnerX(n)
return self.muc_child
n=n.next | python | {
"resource": ""
} |
q259550 | MucStanzaExt.clear_muc_child | validation | def clear_muc_child(self):
"""
Remove the MUC specific stanza payload element.
"""
if self.muc_child:
self.muc_child.free_borrowed()
self.muc_child=None
if not self.xmlnode.children:
return
n=self.xmlnode.children
while n:
if n.name not in ("x","query"):
n=n.next
continue
ns=n.ns()
if not ns:
n=n.next
continue
ns_uri=ns.getContent()
if ns_uri in (MUC_NS,MUC_USER_NS,MUC_ADMIN_NS,MUC_OWNER_NS):
n.unlinkNode()
n.freeNode()
n=n.next | python | {
"resource": ""
} |
q259551 | MucPresence.make_join_request | validation | def make_join_request(self, password = None, history_maxchars = None,
history_maxstanzas = None, history_seconds = None,
history_since = None):
"""
Make the presence stanza a MUC room join request.
:Parameters:
- `password`: password to the room.
- `history_maxchars`: limit of the total number of characters in
history.
- `history_maxstanzas`: limit of the total number of messages in
history.
- `history_seconds`: send only messages received in the last
`seconds` seconds.
- `history_since`: Send only the messages received since the
dateTime specified (UTC).
:Types:
- `password`: `unicode`
- `history_maxchars`: `int`
- `history_maxstanzas`: `int`
- `history_seconds`: `int`
- `history_since`: `datetime.datetime`
"""
self.clear_muc_child()
self.muc_child=MucX(parent=self.xmlnode)
if (history_maxchars is not None or history_maxstanzas is not None
or history_seconds is not None or history_since is not None):
history = HistoryParameters(history_maxchars, history_maxstanzas,
history_seconds, history_since)
self.muc_child.set_history(history)
if password is not None:
self.muc_child.set_password(password) | python | {
"resource": ""
} |
q259552 | MucPresence.get_join_info | validation | def get_join_info(self):
"""If `self` is a MUC room join request return the information contained.
:return: the join request details or `None`.
:returntype: `MucX`
"""
x=self.get_muc_child()
if not x:
return None
if not isinstance(x,MucX):
return None
return x | python | {
"resource": ""
} |
q259553 | MucIq.make_kick_request | validation | def make_kick_request(self,nick,reason):
"""
Make the iq stanza a MUC room participant kick request.
:Parameters:
- `nick`: nickname of user to kick.
- `reason`: reason of the kick.
:Types:
- `nick`: `unicode`
- `reason`: `unicode`
:return: object describing the kick request details.
:returntype: `MucItem`
"""
self.clear_muc_child()
self.muc_child=MucAdminQuery(parent=self.xmlnode)
item=MucItem("none","none",nick=nick,reason=reason)
self.muc_child.add_item(item)
return self.muc_child | python | {
"resource": ""
} |
q259554 | nfkc | validation | def nfkc(data):
"""Do NFKC normalization of Unicode data.
:Parameters:
- `data`: list of Unicode characters or Unicode string.
:return: normalized Unicode string."""
if isinstance(data, list):
data = u"".join(data)
return unicodedata.normalize("NFKC", data) | python | {
"resource": ""
} |
q259555 | set_stringprep_cache_size | validation | def set_stringprep_cache_size(size):
"""Modify stringprep cache size.
:Parameters:
- `size`: new cache size
"""
# pylint: disable-msg=W0603
global _stringprep_cache_size
_stringprep_cache_size = size
if len(Profile.cache_items) > size:
remove = Profile.cache_items[:-size]
for profile, key in remove:
try:
del profile.cache[key]
except KeyError:
pass
Profile.cache_items = Profile.cache_items[-size:] | python | {
"resource": ""
} |
q259556 | Profile.map | validation | def map(self, data):
"""Mapping part of string preparation."""
result = []
for char in data:
ret = None
for lookup in self.mapping:
ret = lookup(char)
if ret is not None:
break
if ret is not None:
result.append(ret)
else:
result.append(char)
return result | python | {
"resource": ""
} |
q259557 | Profile.prohibit | validation | def prohibit(self, data):
"""Checks for prohibited characters."""
for char in data:
for lookup in self.prohibited:
if lookup(char):
raise StringprepError("Prohibited character: {0!r}"
.format(char))
return data | python | {
"resource": ""
} |
q259558 | Profile.check_unassigned | validation | def check_unassigned(self, data):
"""Checks for unassigned character codes."""
for char in data:
for lookup in self.unassigned:
if lookup(char):
raise StringprepError("Unassigned character: {0!r}"
.format(char))
return data | python | {
"resource": ""
} |
q259559 | Profile.check_bidi | validation | def check_bidi(data):
"""Checks if sting is valid for bidirectional printing."""
has_l = False
has_ral = False
for char in data:
if stringprep.in_table_d1(char):
has_ral = True
elif stringprep.in_table_d2(char):
has_l = True
if has_l and has_ral:
raise StringprepError("Both RandALCat and LCat characters present")
if has_ral and (not stringprep.in_table_d1(data[0])
or not stringprep.in_table_d1(data[-1])):
raise StringprepError("The first and the last character must"
" be RandALCat")
return data | python | {
"resource": ""
} |
q259560 | hold_exception | validation | def hold_exception(method):
"""Decorator for glib callback methods of GLibMainLoop used to store the
exception raised."""
@functools.wraps(method)
def wrapper(self, *args, **kwargs):
"""Wrapper for methods decorated with `hold_exception`."""
# pylint: disable=W0703,W0212
try:
return method(self, *args, **kwargs)
except Exception:
if self.exc_info:
raise
if not self._stack:
logger.debug('@hold_exception wrapped method {0!r} called'
' from outside of the main loop'.format(method))
raise
self.exc_info = sys.exc_info()
logger.debug(u"exception in glib main loop callback:",
exc_info = self.exc_info)
# pylint: disable=W0212
main_loop = self._stack[-1]
if main_loop is not None:
main_loop.quit()
return False
return wrapper | python | {
"resource": ""
} |
q259561 | GLibMainLoop._configure_io_handler | validation | def _configure_io_handler(self, handler):
"""Register an io-handler with the glib main loop."""
if self.check_events():
return
if handler in self._unprepared_handlers:
old_fileno = self._unprepared_handlers[handler]
prepared = self._prepare_io_handler(handler)
else:
old_fileno = None
prepared = True
fileno = handler.fileno()
if old_fileno is not None and fileno != old_fileno:
tag = self._io_sources.pop(handler, None)
if tag is not None:
glib.source_remove(tag)
if not prepared:
self._unprepared_handlers[handler] = fileno
if fileno is None:
logger.debug(" {0!r}.fileno() is None, not polling"
.format(handler))
return
events = 0
if handler.is_readable():
logger.debug(" {0!r} readable".format(handler))
events |= glib.IO_IN | glib.IO_ERR
if handler.is_writable():
logger.debug(" {0!r} writable".format(handler))
events |= glib.IO_OUT | glib.IO_HUP | glib.IO_ERR
if events:
logger.debug(" registering {0!r} handler fileno {1} for"
" events {2}".format(handler, fileno, events))
glib.io_add_watch(fileno, events, self._io_callback, handler) | python | {
"resource": ""
} |
q259562 | GLibMainLoop._prepare_pending | validation | def _prepare_pending(self):
"""Prepare pending handlers.
"""
if not self._unprepared_pending:
return
for handler in list(self._unprepared_pending):
self._configure_io_handler(handler)
self.check_events() | python | {
"resource": ""
} |
q259563 | GLibMainLoop._prepare_io_handler_cb | validation | def _prepare_io_handler_cb(self, handler):
"""Timeout callback called to try prepare an IOHandler again."""
self._anything_done = True
logger.debug("_prepar_io_handler_cb called for {0!r}".format(handler))
self._configure_io_handler(handler)
self._prepare_sources.pop(handler, None)
return False | python | {
"resource": ""
} |
q259564 | GLibMainLoop._timeout_cb | validation | def _timeout_cb(self, method):
"""Call the timeout handler due.
"""
self._anything_done = True
logger.debug("_timeout_cb() called for: {0!r}".format(method))
result = method()
# pylint: disable=W0212
rec = method._pyxmpp_recurring
if rec:
self._prepare_pending()
return True
if rec is None and result is not None:
logger.debug(" auto-recurring, restarting in {0} s"
.format(result))
tag = glib.timeout_add(int(result * 1000), self._timeout_cb, method)
self._timer_sources[method] = tag
else:
self._timer_sources.pop(method, None)
self._prepare_pending()
return False | python | {
"resource": ""
} |
q259565 | GLibMainLoop._loop_timeout_cb | validation | def _loop_timeout_cb(self, main_loop):
"""Stops the loop after the time specified in the `loop` call.
"""
self._anything_done = True
logger.debug("_loop_timeout_cb() called")
main_loop.quit() | python | {
"resource": ""
} |
q259566 | stanza_factory | validation | def stanza_factory(element, return_path = None, language = None):
"""Creates Iq, Message or Presence object for XML stanza `element`
:Parameters:
- `element`: the stanza XML element
- `return_path`: object through which responses to this stanza should
be sent (will be weakly referenced by the stanza object).
- `language`: default language for the stanza
:Types:
- `element`: :etree:`ElementTree.Element`
- `return_path`: `StanzaRoute`
- `language`: `unicode`
"""
tag = element.tag
if tag.endswith("}iq") or tag == "iq":
return Iq(element, return_path = return_path, language = language)
if tag.endswith("}message") or tag == "message":
return Message(element, return_path = return_path, language = language)
if tag.endswith("}presence") or tag == "presence":
return Presence(element, return_path = return_path, language = language)
else:
return Stanza(element, return_path = return_path, language = language) | python | {
"resource": ""
} |
q259567 | StanzaProcessor._process_handler_result | validation | def _process_handler_result(self, response):
"""Examines out the response returned by a stanza handler and sends all
stanzas provided.
:Parameters:
- `response`: the response to process. `None` or `False` means 'not
handled'. `True` means 'handled'. Stanza or stanza list means
handled with the stanzas to send back
:Types:
- `response`: `bool` or `Stanza` or iterable of `Stanza`
:Returns:
- `True`: if `response` is `Stanza`, iterable or `True` (meaning
the stanza was processed).
- `False`: when `response` is `False` or `None`
:returntype: `bool`
"""
if response is None or response is False:
return False
if isinstance(response, Stanza):
self.send(response)
return True
try:
response = iter(response)
except TypeError:
return bool(response)
for stanza in response:
if isinstance(stanza, Stanza):
self.send(stanza)
else:
logger.warning(u"Unexpected object in stanza handler result:"
u" {0!r}".format(stanza))
return True | python | {
"resource": ""
} |
q259568 | StanzaProcessor._process_iq_response | validation | def _process_iq_response(self, stanza):
"""Process IQ stanza of type 'response' or 'error'.
:Parameters:
- `stanza`: the stanza received
:Types:
- `stanza`: `Iq`
If a matching handler is available pass the stanza to it. Otherwise
ignore it if it is "error" or "result" stanza or return
"feature-not-implemented" error if it is "get" or "set".
"""
stanza_id = stanza.stanza_id
from_jid = stanza.from_jid
if from_jid:
ufrom = from_jid.as_unicode()
else:
ufrom = None
res_handler = err_handler = None
try:
res_handler, err_handler = self._iq_response_handlers.pop(
(stanza_id, ufrom))
except KeyError:
logger.debug("No response handler for id={0!r} from={1!r}"
.format(stanza_id, ufrom))
logger.debug(" from_jid: {0!r} peer: {1!r} me: {2!r}"
.format(from_jid, self.peer, self.me))
if ( (from_jid == self.peer or from_jid == self.me
or self.me and from_jid == self.me.bare()) ):
try:
logger.debug(" trying id={0!r} from=None"
.format(stanza_id))
res_handler, err_handler = \
self._iq_response_handlers.pop(
(stanza_id, None))
except KeyError:
pass
if stanza.stanza_type == "result":
if res_handler:
response = res_handler(stanza)
else:
return False
else:
if err_handler:
response = err_handler(stanza)
else:
return False
self._process_handler_result(response)
return True | python | {
"resource": ""
} |
q259569 | StanzaProcessor.process_iq | validation | def process_iq(self, stanza):
"""Process IQ stanza received.
:Parameters:
- `stanza`: the stanza received
:Types:
- `stanza`: `Iq`
If a matching handler is available pass the stanza to it. Otherwise
ignore it if it is "error" or "result" stanza or return
"feature-not-implemented" error if it is "get" or "set"."""
typ = stanza.stanza_type
if typ in ("result", "error"):
return self._process_iq_response(stanza)
if typ not in ("get", "set"):
raise BadRequestProtocolError("Bad <iq/> type")
logger.debug("Handling <iq type='{0}'> stanza: {1!r}".format(
stanza, typ))
payload = stanza.get_payload(None)
logger.debug(" payload: {0!r}".format(payload))
if not payload:
raise BadRequestProtocolError("<iq/> stanza with no child element")
handler = self._get_iq_handler(typ, payload)
if not handler:
payload = stanza.get_payload(None, specialize = True)
logger.debug(" specialized payload: {0!r}".format(payload))
if not isinstance(payload, XMLPayload):
handler = self._get_iq_handler(typ, payload)
if handler:
response = handler(stanza)
self._process_handler_result(response)
return True
else:
raise ServiceUnavailableProtocolError("Not implemented") | python | {
"resource": ""
} |
q259570 | StanzaProcessor.__try_handlers | validation | def __try_handlers(self, handler_list, stanza, stanza_type = None):
""" Search the handler list for handlers matching
given stanza type and payload namespace. Run the
handlers found ordering them by priority until
the first one which returns `True`.
:Parameters:
- `handler_list`: list of available handlers
- `stanza`: the stanza to handle
- `stanza_type`: stanza type override (value of its "type"
attribute)
:return: result of the last handler or `False` if no
handler was found.
"""
# pylint: disable=W0212
if stanza_type is None:
stanza_type = stanza.stanza_type
payload = stanza.get_all_payload()
classes = [p.__class__ for p in payload]
keys = [(p.__class__, p.handler_key) for p in payload]
for handler in handler_list:
type_filter = handler._pyxmpp_stanza_handled[1]
class_filter = handler._pyxmpp_payload_class_handled
extra_filter = handler._pyxmpp_payload_key
if type_filter != stanza_type:
continue
if class_filter:
if extra_filter is None and class_filter not in classes:
continue
if extra_filter and (class_filter, extra_filter) not in keys:
continue
response = handler(stanza)
if self._process_handler_result(response):
return True
return False | python | {
"resource": ""
} |
q259571 | StanzaProcessor.process_message | validation | def process_message(self, stanza):
"""Process message stanza.
Pass it to a handler of the stanza's type and payload namespace.
If no handler for the actual stanza type succeeds then hadlers
for type "normal" are used.
:Parameters:
- `stanza`: message stanza to be handled
"""
stanza_type = stanza.stanza_type
if stanza_type is None:
stanza_type = "normal"
if self.__try_handlers(self._message_handlers, stanza,
stanza_type = stanza_type):
return True
if stanza_type not in ("error", "normal"):
# try 'normal' handler additionaly to the regular handler
return self.__try_handlers(self._message_handlers, stanza,
stanza_type = "normal")
return False | python | {
"resource": ""
} |
q259572 | StanzaProcessor.process_presence | validation | def process_presence(self, stanza):
"""Process presence stanza.
Pass it to a handler of the stanza's type and payload namespace.
:Parameters:
- `stanza`: presence stanza to be handled
"""
stanza_type = stanza.stanza_type
return self.__try_handlers(self._presence_handlers, stanza, stanza_type) | python | {
"resource": ""
} |
q259573 | StanzaProcessor.route_stanza | validation | def route_stanza(self, stanza):
"""Process stanza not addressed to us.
Return "recipient-unavailable" return if it is not
"error" nor "result" stanza.
This method should be overriden in derived classes if they
are supposed to handle stanzas not addressed directly to local
stream endpoint.
:Parameters:
- `stanza`: presence stanza to be processed
"""
if stanza.stanza_type not in ("error", "result"):
response = stanza.make_error_response(u"recipient-unavailable")
self.send(response)
return True | python | {
"resource": ""
} |
q259574 | StanzaProcessor.process_stanza | validation | def process_stanza(self, stanza):
"""Process stanza received from the stream.
First "fix" the stanza with `self.fix_in_stanza()`,
then pass it to `self.route_stanza()` if it is not directed
to `self.me` and `self.process_all_stanzas` is not True. Otherwise
stanza is passwd to `self.process_iq()`, `self.process_message()`
or `self.process_presence()` appropriately.
:Parameters:
- `stanza`: the stanza received.
:returns: `True` when stanza was handled
"""
self.fix_in_stanza(stanza)
to_jid = stanza.to_jid
if not self.process_all_stanzas and to_jid and (
to_jid != self.me and to_jid.bare() != self.me.bare()):
return self.route_stanza(stanza)
try:
if isinstance(stanza, Iq):
if self.process_iq(stanza):
return True
elif isinstance(stanza, Message):
if self.process_message(stanza):
return True
elif isinstance(stanza, Presence):
if self.process_presence(stanza):
return True
except ProtocolError, err:
typ = stanza.stanza_type
if typ != 'error' and (typ != 'result'
or stanza.stanza_type != 'iq'):
response = stanza.make_error_response(err.xmpp_name)
self.send(response)
err.log_reported()
else:
err.log_ignored()
return
logger.debug("Unhandled %r stanza: %r" % (stanza.stanza_type,
stanza.serialize()))
return False | python | {
"resource": ""
} |
q259575 | StanzaProcessor.set_response_handlers | validation | def set_response_handlers(self, stanza, res_handler, err_handler,
timeout_handler = None, timeout = None):
"""Set response handler for an IQ "get" or "set" stanza.
This should be called before the stanza is sent.
:Parameters:
- `stanza`: an IQ stanza
- `res_handler`: result handler for the stanza. Will be called
when matching <iq type="result"/> is received. Its only
argument will be the stanza received. The handler may return
a stanza or list of stanzas which should be sent in response.
- `err_handler`: error handler for the stanza. Will be called
when matching <iq type="error"/> is received. Its only
argument will be the stanza received. The handler may return
a stanza or list of stanzas which should be sent in response
but this feature should rather not be used (it is better not to
respond to 'error' stanzas).
- `timeout_handler`: timeout handler for the stanza. Will be called
(with no arguments) when no matching <iq type="result"/> or <iq
type="error"/> is received in next `timeout` seconds.
- `timeout`: timeout value for the stanza. After that time if no
matching <iq type="result"/> nor <iq type="error"/> stanza is
received, then timeout_handler (if given) will be called.
"""
# pylint: disable-msg=R0913
self.lock.acquire()
try:
self._set_response_handlers(stanza, res_handler, err_handler,
timeout_handler, timeout)
finally:
self.lock.release() | python | {
"resource": ""
} |
q259576 | StanzaProcessor._set_response_handlers | validation | def _set_response_handlers(self, stanza, res_handler, err_handler,
timeout_handler = None, timeout = None):
"""Same as `set_response_handlers` but assume `self.lock` is
acquired."""
# pylint: disable-msg=R0913
self.fix_out_stanza(stanza)
to_jid = stanza.to_jid
if to_jid:
to_jid = unicode(to_jid)
if timeout_handler:
def callback(dummy1, dummy2):
"""Wrapper for the timeout handler to make it compatible
with the `ExpiringDictionary` """
timeout_handler()
self._iq_response_handlers.set_item(
(stanza.stanza_id, to_jid),
(res_handler,err_handler),
timeout, callback)
else:
self._iq_response_handlers.set_item(
(stanza.stanza_id, to_jid),
(res_handler, err_handler),
timeout) | python | {
"resource": ""
} |
q259577 | StanzaProcessor.setup_stanza_handlers | validation | def setup_stanza_handlers(self, handler_objects, usage_restriction):
"""Install stanza handlers provided by `handler_objects`"""
# pylint: disable=W0212
iq_handlers = {"get": {}, "set": {}}
message_handlers = []
presence_handlers = []
for obj in handler_objects:
if not isinstance(obj, XMPPFeatureHandler):
continue
obj.stanza_processor = self
for dummy, handler in inspect.getmembers(obj, callable):
if not hasattr(handler, "_pyxmpp_stanza_handled"):
continue
element_name, stanza_type = handler._pyxmpp_stanza_handled
restr = handler._pyxmpp_usage_restriction
if restr and restr != usage_restriction:
continue
if element_name == "iq":
payload_class = handler._pyxmpp_payload_class_handled
payload_key = handler._pyxmpp_payload_key
if (payload_class, payload_key) in iq_handlers[stanza_type]:
continue
iq_handlers[stanza_type][(payload_class, payload_key)] = \
handler
continue
elif element_name == "message":
handler_list = message_handlers
elif element_name == "presence":
handler_list = presence_handlers
else:
raise ValueError, "Bad handler decoration"
handler_list.append(handler)
with self.lock:
self._iq_handlers = iq_handlers
self._presence_handlers = presence_handlers
self._message_handlers = message_handlers | python | {
"resource": ""
} |
q259578 | StanzaProcessor.send | validation | def send(self, stanza):
"""Send a stanza somwhere.
The default implementation sends it via the `uplink` if it is defined
or raises the `NoRouteError`.
:Parameters:
- `stanza`: the stanza to send.
:Types:
- `stanza`: `pyxmpp.stanza.Stanza`"""
if self.uplink:
self.uplink.send(stanza)
else:
raise NoRouteError("No route for stanza") | python | {
"resource": ""
} |
q259579 | MainLoopBase.check_events | validation | def check_events(self):
"""Call the event dispatcher.
Quit the main loop when the `QUIT` event is reached.
:Return: `True` if `QUIT` was reached.
"""
if self.event_dispatcher.flush() is QUIT:
self._quit = True
return True
return False | python | {
"resource": ""
} |
q259580 | MainLoopBase._call_timeout_handlers | validation | def _call_timeout_handlers(self):
"""Call the timeout handlers due.
:Return: (next_event_timeout, sources_handled) tuple.
next_event_timeout is number of seconds until the next timeout
event, sources_handled is number of handlers called.
"""
sources_handled = 0
now = time.time()
schedule = None
while self._timeout_handlers:
schedule, handler = self._timeout_handlers[0]
if schedule <= now:
# pylint: disable-msg=W0212
logger.debug("About to call a timeout handler: {0!r}"
.format(handler))
self._timeout_handlers = self._timeout_handlers[1:]
result = handler()
logger.debug(" handler result: {0!r}".format(result))
rec = handler._pyxmpp_recurring
if rec:
logger.debug(" recurring, restarting in {0} s"
.format(handler._pyxmpp_timeout))
self._timeout_handlers.append(
(now + handler._pyxmpp_timeout, handler))
self._timeout_handlers.sort(key = lambda x: x[0])
elif rec is None and result is not None:
logger.debug(" auto-recurring, restarting in {0} s"
.format(result))
self._timeout_handlers.append((now + result, handler))
self._timeout_handlers.sort(key = lambda x: x[0])
sources_handled += 1
else:
break
if self.check_events():
return 0, sources_handled
if self._timeout_handlers and schedule:
timeout = schedule - now
else:
timeout = None
return timeout, sources_handled | python | {
"resource": ""
} |
q259581 | xml_elements_equal | validation | def xml_elements_equal(element1, element2, ignore_level1_cdata = False):
"""Check if two XML elements are equal.
:Parameters:
- `element1`: the first element to compare
- `element2`: the other element to compare
- `ignore_level1_cdata`: if direct text children of the elements
should be ignored for the comparision
:Types:
- `element1`: :etree:`ElementTree.Element`
- `element2`: :etree:`ElementTree.Element`
- `ignore_level1_cdata`: `bool`
:Returntype: `bool`
"""
# pylint: disable-msg=R0911
if None in (element1, element2) or element1.tag != element2.tag:
return False
attrs1 = element1.items()
attrs1.sort()
attrs2 = element2.items()
attrs2.sort()
if not ignore_level1_cdata:
if element1.text != element2.text:
return False
if attrs1 != attrs2:
return False
if len(element1) != len(element2):
return False
for child1, child2 in zip(element1, element2):
if child1.tag != child2.tag:
return False
if not ignore_level1_cdata:
if element1.text != element2.text:
return False
if not xml_elements_equal(child1, child2):
return False
return True | python | {
"resource": ""
} |
q259582 | Message.make_error_response | validation | def make_error_response(self, cond):
"""Create error response for any non-error message stanza.
:Parameters:
- `cond`: error condition name, as defined in XMPP specification.
:return: new message stanza with the same "id" as self, "from" and
"to" attributes swapped, type="error" and containing <error />
element plus payload of `self`.
:returntype: `Message`"""
if self.stanza_type == "error":
raise ValueError("Errors may not be generated in response"
" to errors")
msg = Message(stanza_type = "error", from_jid = self.to_jid,
to_jid = self.from_jid, stanza_id = self.stanza_id,
error_cond = cond,
subject = self._subject, body = self._body,
thread = self._thread)
if self._payload is None:
self.decode_payload()
for payload in self._payload:
msg.add_payload(payload.copy())
return msg | python | {
"resource": ""
} |
q259583 | _move_session_handler | validation | def _move_session_handler(handlers):
"""Find a SessionHandler instance in the list and move it to the beginning.
"""
index = 0
for i, handler in enumerate(handlers):
if isinstance(handler, SessionHandler):
index = i
break
if index:
handlers[:index + 1] = [handlers[index]] + handlers[:index] | python | {
"resource": ""
} |
q259584 | Client.connect | validation | def connect(self):
"""Schedule a new XMPP c2s connection.
"""
with self.lock:
if self.stream:
logger.debug("Closing the previously used stream.")
self._close_stream()
transport = TCPTransport(self.settings)
addr = self.settings["server"]
if addr:
service = None
else:
addr = self.jid.domain
service = self.settings["c2s_service"]
transport.connect(addr, self.settings["c2s_port"], service)
handlers = self._base_handlers[:]
handlers += self.handlers + [self]
self.clear_response_handlers()
self.setup_stanza_handlers(handlers, "pre-auth")
stream = ClientStream(self.jid, self, handlers, self.settings)
stream.initiate(transport)
self.main_loop.add_handler(transport)
self.main_loop.add_handler(stream)
self._ml_handlers += [transport, stream]
self.stream = stream
self.uplink = stream | python | {
"resource": ""
} |
q259585 | Client.disconnect | validation | def disconnect(self):
"""Gracefully disconnect from the server."""
with self.lock:
if self.stream:
if self.settings[u"initial_presence"]:
self.send(Presence(stanza_type = "unavailable"))
self.stream.disconnect() | python | {
"resource": ""
} |
q259586 | Client._close_stream | validation | def _close_stream(self):
"""Same as `close_stream` but with the `lock` acquired.
"""
self.stream.close()
if self.stream.transport in self._ml_handlers:
self._ml_handlers.remove(self.stream.transport)
self.main_loop.remove_handler(self.stream.transport)
self.stream = None
self.uplink = None | python | {
"resource": ""
} |
q259587 | Client._stream_authenticated | validation | def _stream_authenticated(self, event):
"""Handle the `AuthenticatedEvent`.
"""
with self.lock:
if event.stream != self.stream:
return
self.me = event.stream.me
self.peer = event.stream.peer
handlers = self._base_handlers[:]
handlers += self.handlers + [self]
self.setup_stanza_handlers(handlers, "post-auth") | python | {
"resource": ""
} |
q259588 | Client._stream_authorized | validation | def _stream_authorized(self, event):
"""Handle the `AuthorizedEvent`.
"""
with self.lock:
if event.stream != self.stream:
return
self.me = event.stream.me
self.peer = event.stream.peer
presence = self.settings[u"initial_presence"]
if presence:
self.send(presence) | python | {
"resource": ""
} |
q259589 | Client._stream_disconnected | validation | def _stream_disconnected(self, event):
"""Handle stream disconnection event.
"""
with self.lock:
if event.stream != self.stream:
return
if self.stream is not None and event.stream == self.stream:
if self.stream.transport in self._ml_handlers:
self._ml_handlers.remove(self.stream.transport)
self.main_loop.remove_handler(self.stream.transport)
self.stream = None
self.uplink = None | python | {
"resource": ""
} |
q259590 | Client.base_handlers_factory | validation | def base_handlers_factory(self):
"""Default base client handlers factory.
Subclasses can provide different behaviour by overriding this.
:Return: list of handlers
"""
tls_handler = StreamTLSHandler(self.settings)
sasl_handler = StreamSASLHandler(self.settings)
session_handler = SessionHandler()
binding_handler = ResourceBindingHandler(self.settings)
return [tls_handler, sasl_handler, binding_handler, session_handler] | python | {
"resource": ""
} |
q259591 | payload_class_for_element_name | validation | def payload_class_for_element_name(element_name):
"""Return a payload class for given element name."""
logger.debug(" looking up payload class for element: {0!r}".format(
element_name))
logger.debug(" known: {0!r}".format(STANZA_PAYLOAD_CLASSES))
if element_name in STANZA_PAYLOAD_CLASSES:
return STANZA_PAYLOAD_CLASSES[element_name]
else:
return XMLPayload | python | {
"resource": ""
} |
q259592 | _unquote | validation | def _unquote(data):
"""Unquote quoted value from DIGEST-MD5 challenge or response.
If `data` doesn't start or doesn't end with '"' then return it unchanged,
remove the quotes and escape backslashes otherwise.
:Parameters:
- `data`: a quoted string.
:Types:
- `data`: `bytes`
:return: the unquoted string.
:returntype: `bytes`
"""
if not data.startswith(b'"') or not data.endswith(b'"'):
return data
return QUOTE_RE.sub(b"\\1", data[1:-1]) | python | {
"resource": ""
} |
q259593 | _quote | validation | def _quote(data):
"""Prepare a string for quoting for DIGEST-MD5 challenge or response.
Don't add the quotes, only escape '"' and "\\" with backslashes.
:Parameters:
- `data`: a raw string.
:Types:
- `data`: `bytes`
:return: `data` with '"' and "\\" escaped using "\\".
:returntype: `bytes`
"""
data = data.replace(b'\\', b'\\\\')
data = data.replace(b'"', b'\\"')
return data | python | {
"resource": ""
} |
q259594 | _compute_response | validation | def _compute_response(urp_hash, nonce, cnonce, nonce_count, authzid,
digest_uri):
"""Compute DIGEST-MD5 response value.
:Parameters:
- `urp_hash`: MD5 sum of username:realm:password.
- `nonce`: nonce value from a server challenge.
- `cnonce`: cnonce value from the client response.
- `nonce_count`: nonce count value.
- `authzid`: authorization id.
- `digest_uri`: digest-uri value.
:Types:
- `urp_hash`: `bytes`
- `nonce`: `bytes`
- `nonce_count`: `int`
- `authzid`: `bytes`
- `digest_uri`: `bytes`
:return: the computed response value.
:returntype: `bytes`"""
# pylint: disable-msg=C0103,R0913
logger.debug("_compute_response{0!r}".format((urp_hash, nonce, cnonce,
nonce_count, authzid,digest_uri)))
if authzid:
a1 = b":".join((urp_hash, nonce, cnonce, authzid))
else:
a1 = b":".join((urp_hash, nonce, cnonce))
a2 = b"AUTHENTICATE:" + digest_uri
return b2a_hex(_kd_value(b2a_hex(_h_value(a1)), b":".join((
nonce, nonce_count, cnonce, b"auth", b2a_hex(_h_value(a2)))))) | python | {
"resource": ""
} |
q259595 | rfc2425encode | validation | def rfc2425encode(name,value,parameters=None,charset="utf-8"):
"""Encodes a vCard field into an RFC2425 line.
:Parameters:
- `name`: field type name
- `value`: field value
- `parameters`: optional parameters
- `charset`: encoding of the output and of the `value` (if not
`unicode`)
:Types:
- `name`: `str`
- `value`: `unicode` or `str`
- `parameters`: `dict` of `str` -> `str`
- `charset`: `str`
:return: the encoded RFC2425 line (possibly folded)
:returntype: `str`"""
if not parameters:
parameters={}
if type(value) is unicode:
value=value.replace(u"\r\n",u"\\n")
value=value.replace(u"\n",u"\\n")
value=value.replace(u"\r",u"\\n")
value=value.encode(charset,"replace")
elif type(value) is not str:
raise TypeError("Bad type for rfc2425 value")
elif not valid_string_re.match(value):
parameters["encoding"]="b"
value=binascii.b2a_base64(value)
ret=str(name).lower()
for k,v in parameters.items():
ret+=";%s=%s" % (str(k),str(v))
ret+=":"
while(len(value)>70):
ret+=value[:70]+"\r\n "
value=value[70:]
ret+=value+"\r\n"
return ret | python | {
"resource": ""
} |
q259596 | VCardAdr.__from_xml | validation | def __from_xml(self,value):
"""Initialize a `VCardAdr` object from and XML element.
:Parameters:
- `value`: field value as an XML node
:Types:
- `value`: `libxml2.xmlNode`"""
n=value.children
vns=get_node_ns(value)
while n:
if n.type!='element':
n=n.next
continue
ns=get_node_ns(n)
if (ns and vns and ns.getContent()!=vns.getContent()):
n=n.next
continue
if n.name=='POBOX':
self.pobox=unicode(n.getContent(),"utf-8","replace")
elif n.name in ('EXTADR', 'EXTADD'):
self.extadr=unicode(n.getContent(),"utf-8","replace")
elif n.name=='STREET':
self.street=unicode(n.getContent(),"utf-8","replace")
elif n.name=='LOCALITY':
self.locality=unicode(n.getContent(),"utf-8","replace")
elif n.name=='REGION':
self.region=unicode(n.getContent(),"utf-8","replace")
elif n.name=='PCODE':
self.pcode=unicode(n.getContent(),"utf-8","replace")
elif n.name=='CTRY':
self.ctry=unicode(n.getContent(),"utf-8","replace")
elif n.name in ("HOME","WORK","POSTAL","PARCEL","DOM","INTL",
"PREF"):
self.type.append(n.name.lower())
n=n.next
if self.type==[]:
self.type=["intl","postal","parcel","work"]
elif "dom" in self.type and "intl" in self.type:
raise ValueError("Both 'dom' and 'intl' specified in vcard ADR") | python | {
"resource": ""
} |
q259597 | VCard.__make_fn | validation | def __make_fn(self):
"""Initialize the mandatory `self.fn` from `self.n`.
This is a workaround for buggy clients which set only one of them."""
s=[]
if self.n.prefix:
s.append(self.n.prefix)
if self.n.given:
s.append(self.n.given)
if self.n.middle:
s.append(self.n.middle)
if self.n.family:
s.append(self.n.family)
if self.n.suffix:
s.append(self.n.suffix)
s=u" ".join(s)
self.content["FN"]=VCardString("FN", s, empty_ok = True) | python | {
"resource": ""
} |
q259598 | VCard.__from_xml | validation | def __from_xml(self,data):
"""Initialize a VCard object from XML node.
:Parameters:
- `data`: vcard to parse.
:Types:
- `data`: `libxml2.xmlNode`"""
ns=get_node_ns(data)
if ns and ns.getContent()!=VCARD_NS:
raise ValueError("Not in the %r namespace" % (VCARD_NS,))
if data.name!="vCard":
raise ValueError("Bad root element name: %r" % (data.name,))
n=data.children
dns=get_node_ns(data)
while n:
if n.type!='element':
n=n.next
continue
ns=get_node_ns(n)
if (ns and dns and ns.getContent()!=dns.getContent()):
n=n.next
continue
if not self.components.has_key(n.name):
n=n.next
continue
cl,tp=self.components[n.name]
if tp in ("required","optional"):
if self.content.has_key(n.name):
raise ValueError("Duplicate %s" % (n.name,))
try:
self.content[n.name]=cl(n.name,n)
except Empty:
pass
elif tp=="multi":
if not self.content.has_key(n.name):
self.content[n.name]=[]
try:
self.content[n.name].append(cl(n.name,n))
except Empty:
pass
n=n.next | python | {
"resource": ""
} |
q259599 | VCard.__from_rfc2426 | validation | def __from_rfc2426(self,data):
"""Initialize a VCard object from an RFC2426 string.
:Parameters:
- `data`: vcard to parse.
:Types:
- `data`: `libxml2.xmlNode`, `unicode` or `str`"""
data=from_utf8(data)
lines=data.split("\n")
started=0
current=None
for l in lines:
if not l:
continue
if l[-1]=="\r":
l=l[:-1]
if not l:
continue
if l[0] in " \t":
if current is None:
continue
current+=l[1:]
continue
if not started and current and current.upper().strip()=="BEGIN:VCARD":
started=1
elif started and current.upper().strip()=="END:VCARD":
current=None
break
elif current and started:
self._process_rfc2425_record(current)
current=l
if started and current:
self._process_rfc2425_record(current) | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.