_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | 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]
# | python | {
"resource": ""
} |
q259501 | piano_roll | validation | def piano_roll(annotation, **kwargs):
'''Plotting wrapper for piano rolls'''
times, midi = annotation.to_interval_values()
| 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 argumen... | 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
... | 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 = | 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.
'''
| 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(interv... | 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(_) ... | 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 toget... | 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()
# Constr... | 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)
... | 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) | 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)... | 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... | 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.initia... | 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 wil... | 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 Delayed... | 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... | 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)
e... | 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'
| 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... | python | {
"resource": ""
} |
q259521 | Roster.groups | validation | def groups(self):
"""Set of groups defined in the roster.
:Return: the groups
:ReturnType: `set` of | 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... | 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`: `... | 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 `V... | 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) | 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`: `... | 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-... | 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) i... | 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:
| 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.
| 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 pus... | 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(
| 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))
ret... | 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 con... | 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 sequenc... | 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... | 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 = RosterPayl... | python | {
"resource": ""
} |
q259538 | MucXBase.free | validation | def free(self):
"""
Unlink and free the XML node owned by `self`.
"""
if not self.borrowed:
| 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... | 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.unli... | 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("maxc... | 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 == "... | 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 | 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`: ... | 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:
... | 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`
"""
| 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.childre... | python | {
"resource": ""
} |
q259548 | MucUserX.add_item | validation | def add_item(self,item):
"""Add an item to `self`.
:Parameters:
- `item`: the item to add.
:Types:
| 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 ... | 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:
... | 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.
... | 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()
| 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:
| python | {
"resource": ""
} |
q259554 | nfkc | validation | def nfkc(data):
"""Do NFKC normalization of Unicode data.
:Parameters:
- `data`: list of Unicode characters or | 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]
... | 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
| 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):
| 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):
| 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
... | 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:
... | 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)... | python | {
"resource": ""
} |
q259562 | GLibMainLoop._prepare_pending | validation | def _prepare_pending(self):
"""Prepare pending handlers.
"""
if not self._unprepared_pending:
return
| 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))
| 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.... | 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.
"""
| 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 reference... | 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 li... | 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 "err... | 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 retur... | 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:
- `h... | 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 ha... | 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
| 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
| 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 `s... | 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 st... | 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 = s... | 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:
... | 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.
| 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.
| 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
... | 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
... | 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, typ... | 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): | 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.setting... | 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"]:
| 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)
| 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
| 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
| 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_handler... | 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
"""
| 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(
| 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` | 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` | 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 challen... | 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
... | 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!=... | 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)
| 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 name... | 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
cur... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.