id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 51
19.8k
| code_tokens
sequence | docstring
stringlengths 3
17.3k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
700 | horazont/aioxmpp | aioxmpp/presence/service.py | PresenceClient.get_most_available_stanza | def get_most_available_stanza(self, peer_jid):
"""
Obtain the stanza describing the most-available presence of the
contact.
:param peer_jid: Bare JID of the contact.
:type peer_jid: :class:`aioxmpp.JID`
:rtype: :class:`aioxmpp.Presence` or :data:`None`
:return: The presence stanza of the most available resource or
:data:`None` if there is no available resource.
The "most available" resource is the one whose presence state orderest
highest according to :class:`~aioxmpp.PresenceState`.
If there is no available resource for a given `peer_jid`, :data:`None`
is returned.
"""
presences = sorted(
self.get_peer_resources(peer_jid).items(),
key=lambda item: aioxmpp.structs.PresenceState.from_stanza(item[1])
)
if not presences:
return None
return presences[-1][1] | python | def get_most_available_stanza(self, peer_jid):
presences = sorted(
self.get_peer_resources(peer_jid).items(),
key=lambda item: aioxmpp.structs.PresenceState.from_stanza(item[1])
)
if not presences:
return None
return presences[-1][1] | [
"def",
"get_most_available_stanza",
"(",
"self",
",",
"peer_jid",
")",
":",
"presences",
"=",
"sorted",
"(",
"self",
".",
"get_peer_resources",
"(",
"peer_jid",
")",
".",
"items",
"(",
")",
",",
"key",
"=",
"lambda",
"item",
":",
"aioxmpp",
".",
"structs",
".",
"PresenceState",
".",
"from_stanza",
"(",
"item",
"[",
"1",
"]",
")",
")",
"if",
"not",
"presences",
":",
"return",
"None",
"return",
"presences",
"[",
"-",
"1",
"]",
"[",
"1",
"]"
] | Obtain the stanza describing the most-available presence of the
contact.
:param peer_jid: Bare JID of the contact.
:type peer_jid: :class:`aioxmpp.JID`
:rtype: :class:`aioxmpp.Presence` or :data:`None`
:return: The presence stanza of the most available resource or
:data:`None` if there is no available resource.
The "most available" resource is the one whose presence state orderest
highest according to :class:`~aioxmpp.PresenceState`.
If there is no available resource for a given `peer_jid`, :data:`None`
is returned. | [
"Obtain",
"the",
"stanza",
"describing",
"the",
"most",
"-",
"available",
"presence",
"of",
"the",
"contact",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/presence/service.py#L123-L146 |
701 | horazont/aioxmpp | aioxmpp/presence/service.py | PresenceClient.get_peer_resources | def get_peer_resources(self, peer_jid):
"""
Return a dict mapping resources of the given bare `peer_jid` to the
presence state last received for that resource.
Unavailable presence states are not included. If the bare JID is in a
error state (i.e. an error presence stanza has been received), the
returned mapping is empty.
"""
try:
d = dict(self._presences[peer_jid])
d.pop(None, None)
return d
except KeyError:
return {} | python | def get_peer_resources(self, peer_jid):
try:
d = dict(self._presences[peer_jid])
d.pop(None, None)
return d
except KeyError:
return {} | [
"def",
"get_peer_resources",
"(",
"self",
",",
"peer_jid",
")",
":",
"try",
":",
"d",
"=",
"dict",
"(",
"self",
".",
"_presences",
"[",
"peer_jid",
"]",
")",
"d",
".",
"pop",
"(",
"None",
",",
"None",
")",
"return",
"d",
"except",
"KeyError",
":",
"return",
"{",
"}"
] | Return a dict mapping resources of the given bare `peer_jid` to the
presence state last received for that resource.
Unavailable presence states are not included. If the bare JID is in a
error state (i.e. an error presence stanza has been received), the
returned mapping is empty. | [
"Return",
"a",
"dict",
"mapping",
"resources",
"of",
"the",
"given",
"bare",
"peer_jid",
"to",
"the",
"presence",
"state",
"last",
"received",
"for",
"that",
"resource",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/presence/service.py#L148-L162 |
702 | horazont/aioxmpp | aioxmpp/presence/service.py | PresenceServer.make_stanza | def make_stanza(self):
"""
Create and return a presence stanza with the current settings.
:return: Presence stanza
:rtype: :class:`aioxmpp.Presence`
"""
stanza = aioxmpp.Presence()
self._state.apply_to_stanza(stanza)
stanza.status.update(self._status)
return stanza | python | def make_stanza(self):
stanza = aioxmpp.Presence()
self._state.apply_to_stanza(stanza)
stanza.status.update(self._status)
return stanza | [
"def",
"make_stanza",
"(",
"self",
")",
":",
"stanza",
"=",
"aioxmpp",
".",
"Presence",
"(",
")",
"self",
".",
"_state",
".",
"apply_to_stanza",
"(",
"stanza",
")",
"stanza",
".",
"status",
".",
"update",
"(",
"self",
".",
"_status",
")",
"return",
"stanza"
] | Create and return a presence stanza with the current settings.
:return: Presence stanza
:rtype: :class:`aioxmpp.Presence` | [
"Create",
"and",
"return",
"a",
"presence",
"stanza",
"with",
"the",
"current",
"settings",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/presence/service.py#L344-L354 |
703 | horazont/aioxmpp | aioxmpp/presence/service.py | PresenceServer.set_presence | def set_presence(self, state, status={}, priority=0):
"""
Change the presence broadcast by the client.
:param state: New presence state to broadcast
:type state: :class:`aioxmpp.PresenceState`
:param status: New status information to broadcast
:type status: :class:`dict` or :class:`str`
:param priority: New priority for the resource
:type priority: :class:`int`
:return: Stanza token of the presence stanza or :data:`None` if the
presence is unchanged or the stream is not connected.
:rtype: :class:`~.stream.StanzaToken`
If the client is currently connected, the new presence is broadcast
immediately.
`status` must be either a string or something which can be passed to
the :class:`dict` constructor. If it is a string, it is wrapped into a
dict using ``{None: status}``. The mapping must map
:class:`~.LanguageTag` objects (or :data:`None`) to strings. The
information will be used to generate internationalised presence status
information. If you do not need internationalisation, simply use the
string version of the argument.
"""
if not isinstance(priority, numbers.Integral):
raise TypeError(
"invalid priority: got {}, expected integer".format(
type(priority)
)
)
if not isinstance(state, aioxmpp.PresenceState):
raise TypeError(
"invalid state: got {}, expected aioxmpp.PresenceState".format(
type(state),
)
)
if isinstance(status, str):
new_status = {None: status}
else:
new_status = dict(status)
new_priority = int(priority)
emit_state_event = self._state != state
emit_overall_event = (
emit_state_event or
self._priority != new_priority or
self._status != new_status
)
self._state = state
self._status = new_status
self._priority = new_priority
if emit_state_event:
self.on_presence_state_changed()
if emit_overall_event:
self.on_presence_changed()
return self.resend_presence() | python | def set_presence(self, state, status={}, priority=0):
if not isinstance(priority, numbers.Integral):
raise TypeError(
"invalid priority: got {}, expected integer".format(
type(priority)
)
)
if not isinstance(state, aioxmpp.PresenceState):
raise TypeError(
"invalid state: got {}, expected aioxmpp.PresenceState".format(
type(state),
)
)
if isinstance(status, str):
new_status = {None: status}
else:
new_status = dict(status)
new_priority = int(priority)
emit_state_event = self._state != state
emit_overall_event = (
emit_state_event or
self._priority != new_priority or
self._status != new_status
)
self._state = state
self._status = new_status
self._priority = new_priority
if emit_state_event:
self.on_presence_state_changed()
if emit_overall_event:
self.on_presence_changed()
return self.resend_presence() | [
"def",
"set_presence",
"(",
"self",
",",
"state",
",",
"status",
"=",
"{",
"}",
",",
"priority",
"=",
"0",
")",
":",
"if",
"not",
"isinstance",
"(",
"priority",
",",
"numbers",
".",
"Integral",
")",
":",
"raise",
"TypeError",
"(",
"\"invalid priority: got {}, expected integer\"",
".",
"format",
"(",
"type",
"(",
"priority",
")",
")",
")",
"if",
"not",
"isinstance",
"(",
"state",
",",
"aioxmpp",
".",
"PresenceState",
")",
":",
"raise",
"TypeError",
"(",
"\"invalid state: got {}, expected aioxmpp.PresenceState\"",
".",
"format",
"(",
"type",
"(",
"state",
")",
",",
")",
")",
"if",
"isinstance",
"(",
"status",
",",
"str",
")",
":",
"new_status",
"=",
"{",
"None",
":",
"status",
"}",
"else",
":",
"new_status",
"=",
"dict",
"(",
"status",
")",
"new_priority",
"=",
"int",
"(",
"priority",
")",
"emit_state_event",
"=",
"self",
".",
"_state",
"!=",
"state",
"emit_overall_event",
"=",
"(",
"emit_state_event",
"or",
"self",
".",
"_priority",
"!=",
"new_priority",
"or",
"self",
".",
"_status",
"!=",
"new_status",
")",
"self",
".",
"_state",
"=",
"state",
"self",
".",
"_status",
"=",
"new_status",
"self",
".",
"_priority",
"=",
"new_priority",
"if",
"emit_state_event",
":",
"self",
".",
"on_presence_state_changed",
"(",
")",
"if",
"emit_overall_event",
":",
"self",
".",
"on_presence_changed",
"(",
")",
"return",
"self",
".",
"resend_presence",
"(",
")"
] | Change the presence broadcast by the client.
:param state: New presence state to broadcast
:type state: :class:`aioxmpp.PresenceState`
:param status: New status information to broadcast
:type status: :class:`dict` or :class:`str`
:param priority: New priority for the resource
:type priority: :class:`int`
:return: Stanza token of the presence stanza or :data:`None` if the
presence is unchanged or the stream is not connected.
:rtype: :class:`~.stream.StanzaToken`
If the client is currently connected, the new presence is broadcast
immediately.
`status` must be either a string or something which can be passed to
the :class:`dict` constructor. If it is a string, it is wrapped into a
dict using ``{None: status}``. The mapping must map
:class:`~.LanguageTag` objects (or :data:`None`) to strings. The
information will be used to generate internationalised presence status
information. If you do not need internationalisation, simply use the
string version of the argument. | [
"Change",
"the",
"presence",
"broadcast",
"by",
"the",
"client",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/presence/service.py#L356-L417 |
704 | horazont/aioxmpp | aioxmpp/presence/service.py | PresenceServer.resend_presence | def resend_presence(self):
"""
Re-send the currently configured presence.
:return: Stanza token of the presence stanza or :data:`None` if the
stream is not established.
:rtype: :class:`~.stream.StanzaToken`
.. note::
:meth:`set_presence` automatically broadcasts the new presence if
any of the parameters changed.
"""
if self.client.established:
return self.client.enqueue(self.make_stanza()) | python | def resend_presence(self):
if self.client.established:
return self.client.enqueue(self.make_stanza()) | [
"def",
"resend_presence",
"(",
"self",
")",
":",
"if",
"self",
".",
"client",
".",
"established",
":",
"return",
"self",
".",
"client",
".",
"enqueue",
"(",
"self",
".",
"make_stanza",
"(",
")",
")"
] | Re-send the currently configured presence.
:return: Stanza token of the presence stanza or :data:`None` if the
stream is not established.
:rtype: :class:`~.stream.StanzaToken`
.. note::
:meth:`set_presence` automatically broadcasts the new presence if
any of the parameters changed. | [
"Re",
"-",
"send",
"the",
"currently",
"configured",
"presence",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/presence/service.py#L419-L434 |
705 | horazont/aioxmpp | aioxmpp/security_layer.py | AbstractPinStore.export_to_json | def export_to_json(self):
"""
Return a JSON dictionary which contains all the pins stored in this
store.
"""
return {
hostname: sorted(self._encode_key(key) for key in pins)
for hostname, pins in self._storage.items()
} | python | def export_to_json(self):
return {
hostname: sorted(self._encode_key(key) for key in pins)
for hostname, pins in self._storage.items()
} | [
"def",
"export_to_json",
"(",
"self",
")",
":",
"return",
"{",
"hostname",
":",
"sorted",
"(",
"self",
".",
"_encode_key",
"(",
"key",
")",
"for",
"key",
"in",
"pins",
")",
"for",
"hostname",
",",
"pins",
"in",
"self",
".",
"_storage",
".",
"items",
"(",
")",
"}"
] | Return a JSON dictionary which contains all the pins stored in this
store. | [
"Return",
"a",
"JSON",
"dictionary",
"which",
"contains",
"all",
"the",
"pins",
"stored",
"in",
"this",
"store",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/security_layer.py#L584-L593 |
706 | horazont/aioxmpp | aioxmpp/security_layer.py | SASLProvider._find_supported | def _find_supported(self, features, mechanism_classes):
"""
Find the first mechansim class which supports a mechanism announced in
the given stream features.
:param features: Current XMPP stream features
:type features: :class:`~.nonza.StreamFeatures`
:param mechanism_classes: SASL mechanism classes to use
:type mechanism_classes: iterable of :class:`SASLMechanism`
sub\\ *classes*
:raises aioxmpp.errors.SASLUnavailable: if the peer does not announce
SASL support
:return: the :class:`SASLMechanism` subclass to use and a token
:rtype: pair
Return a supported SASL mechanism class, by looking the given
stream features `features`.
If no matching mechanism is found, ``(None, None)`` is
returned. Otherwise, a pair consisting of the mechanism class and the
value returned by the respective
:meth:`~.sasl.SASLMechanism.any_supported` method is returned. The
latter is an opaque token which must be passed to the `token` argument
of :meth:`_execute` or :meth:`aiosasl.SASLMechanism.authenticate`.
"""
try:
mechanisms = features[SASLMechanisms]
except KeyError:
logger.error("No sasl mechanisms: %r", list(features))
raise errors.SASLUnavailable(
"Remote side does not support SASL") from None
remote_mechanism_list = mechanisms.get_mechanism_list()
for our_mechanism in mechanism_classes:
token = our_mechanism.any_supported(remote_mechanism_list)
if token is not None:
return our_mechanism, token
return None, None | python | def _find_supported(self, features, mechanism_classes):
try:
mechanisms = features[SASLMechanisms]
except KeyError:
logger.error("No sasl mechanisms: %r", list(features))
raise errors.SASLUnavailable(
"Remote side does not support SASL") from None
remote_mechanism_list = mechanisms.get_mechanism_list()
for our_mechanism in mechanism_classes:
token = our_mechanism.any_supported(remote_mechanism_list)
if token is not None:
return our_mechanism, token
return None, None | [
"def",
"_find_supported",
"(",
"self",
",",
"features",
",",
"mechanism_classes",
")",
":",
"try",
":",
"mechanisms",
"=",
"features",
"[",
"SASLMechanisms",
"]",
"except",
"KeyError",
":",
"logger",
".",
"error",
"(",
"\"No sasl mechanisms: %r\"",
",",
"list",
"(",
"features",
")",
")",
"raise",
"errors",
".",
"SASLUnavailable",
"(",
"\"Remote side does not support SASL\"",
")",
"from",
"None",
"remote_mechanism_list",
"=",
"mechanisms",
".",
"get_mechanism_list",
"(",
")",
"for",
"our_mechanism",
"in",
"mechanism_classes",
":",
"token",
"=",
"our_mechanism",
".",
"any_supported",
"(",
"remote_mechanism_list",
")",
"if",
"token",
"is",
"not",
"None",
":",
"return",
"our_mechanism",
",",
"token",
"return",
"None",
",",
"None"
] | Find the first mechansim class which supports a mechanism announced in
the given stream features.
:param features: Current XMPP stream features
:type features: :class:`~.nonza.StreamFeatures`
:param mechanism_classes: SASL mechanism classes to use
:type mechanism_classes: iterable of :class:`SASLMechanism`
sub\\ *classes*
:raises aioxmpp.errors.SASLUnavailable: if the peer does not announce
SASL support
:return: the :class:`SASLMechanism` subclass to use and a token
:rtype: pair
Return a supported SASL mechanism class, by looking the given
stream features `features`.
If no matching mechanism is found, ``(None, None)`` is
returned. Otherwise, a pair consisting of the mechanism class and the
value returned by the respective
:meth:`~.sasl.SASLMechanism.any_supported` method is returned. The
latter is an opaque token which must be passed to the `token` argument
of :meth:`_execute` or :meth:`aiosasl.SASLMechanism.authenticate`. | [
"Find",
"the",
"first",
"mechansim",
"class",
"which",
"supports",
"a",
"mechanism",
"announced",
"in",
"the",
"given",
"stream",
"features",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/security_layer.py#L764-L804 |
707 | horazont/aioxmpp | aioxmpp/security_layer.py | SASLProvider._execute | def _execute(self, intf, mechanism, token):
"""
Execute a SASL authentication process.
:param intf: SASL interface to use
:type intf: :class:`~.sasl.SASLXMPPInterface`
:param mechanism: SASL mechanism to use
:type mechanism: :class:`aiosasl.SASLMechanism`
:param token: The opaque token argument for the mechanism
:type token: not :data:`None`
:raises aiosasl.AuthenticationFailure: if authentication failed due to
bad credentials
:raises aiosasl.SASLFailure: on other SASL error conditions (such as
protocol violations)
:return: true if authentication succeeded, false if the mechanism has
to be disabled
:rtype: :class:`bool`
This executes the SASL authentication process. The more specific
exceptions are generated by inspecting the
:attr:`aiosasl.SASLFailure.opaque_error` on exceptinos raised from the
:class:`~.sasl.SASLXMPPInterface`. Other :class:`aiosasl.SASLFailure`
exceptions are re-raised without modification.
"""
sm = aiosasl.SASLStateMachine(intf)
try:
yield from mechanism.authenticate(sm, token)
return True
except aiosasl.SASLFailure as err:
if err.opaque_error in self.AUTHENTICATION_FAILURES:
raise aiosasl.AuthenticationFailure(
opaque_error=err.opaque_error,
text=err.text)
elif err.opaque_error in self.MECHANISM_REJECTED_FAILURES:
return False
raise | python | def _execute(self, intf, mechanism, token):
sm = aiosasl.SASLStateMachine(intf)
try:
yield from mechanism.authenticate(sm, token)
return True
except aiosasl.SASLFailure as err:
if err.opaque_error in self.AUTHENTICATION_FAILURES:
raise aiosasl.AuthenticationFailure(
opaque_error=err.opaque_error,
text=err.text)
elif err.opaque_error in self.MECHANISM_REJECTED_FAILURES:
return False
raise | [
"def",
"_execute",
"(",
"self",
",",
"intf",
",",
"mechanism",
",",
"token",
")",
":",
"sm",
"=",
"aiosasl",
".",
"SASLStateMachine",
"(",
"intf",
")",
"try",
":",
"yield",
"from",
"mechanism",
".",
"authenticate",
"(",
"sm",
",",
"token",
")",
"return",
"True",
"except",
"aiosasl",
".",
"SASLFailure",
"as",
"err",
":",
"if",
"err",
".",
"opaque_error",
"in",
"self",
".",
"AUTHENTICATION_FAILURES",
":",
"raise",
"aiosasl",
".",
"AuthenticationFailure",
"(",
"opaque_error",
"=",
"err",
".",
"opaque_error",
",",
"text",
"=",
"err",
".",
"text",
")",
"elif",
"err",
".",
"opaque_error",
"in",
"self",
".",
"MECHANISM_REJECTED_FAILURES",
":",
"return",
"False",
"raise"
] | Execute a SASL authentication process.
:param intf: SASL interface to use
:type intf: :class:`~.sasl.SASLXMPPInterface`
:param mechanism: SASL mechanism to use
:type mechanism: :class:`aiosasl.SASLMechanism`
:param token: The opaque token argument for the mechanism
:type token: not :data:`None`
:raises aiosasl.AuthenticationFailure: if authentication failed due to
bad credentials
:raises aiosasl.SASLFailure: on other SASL error conditions (such as
protocol violations)
:return: true if authentication succeeded, false if the mechanism has
to be disabled
:rtype: :class:`bool`
This executes the SASL authentication process. The more specific
exceptions are generated by inspecting the
:attr:`aiosasl.SASLFailure.opaque_error` on exceptinos raised from the
:class:`~.sasl.SASLXMPPInterface`. Other :class:`aiosasl.SASLFailure`
exceptions are re-raised without modification. | [
"Execute",
"a",
"SASL",
"authentication",
"process",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/security_layer.py#L821-L856 |
708 | horazont/aioxmpp | aioxmpp/im/conversation.py | AbstractConversation.send_message | def send_message(self, body):
"""
Send a message to the conversation.
:param msg: The message to send.
:type msg: :class:`aioxmpp.Message`
:return: The stanza token obtained from sending.
:rtype: :class:`~aioxmpp.stream.StanzaToken`
The default implementation simply calls :meth:`send_message_tracked`
and immediately cancels the tracking object, returning only the stanza
token.
There is no need to provide proper address attributes on `msg`.
Implementations will override those attributes with the values
appropriate for the conversation. Some implementations may allow the
user to choose a :attr:`~aioxmpp.Message.type_`, but others may simply
stamp it over.
Subclasses may override this method with a more specialised
implementation. Subclasses which do not provide tracked message sending
**must** override this method to provide untracked message sending.
.. seealso::
The corresponding feature is
:attr:`.ConversationFeature.SEND_MESSAGE`. See :attr:`features` for
details.
"""
token, tracker = self.send_message_tracked(body)
tracker.cancel()
return token | python | def send_message(self, body):
token, tracker = self.send_message_tracked(body)
tracker.cancel()
return token | [
"def",
"send_message",
"(",
"self",
",",
"body",
")",
":",
"token",
",",
"tracker",
"=",
"self",
".",
"send_message_tracked",
"(",
"body",
")",
"tracker",
".",
"cancel",
"(",
")",
"return",
"token"
] | Send a message to the conversation.
:param msg: The message to send.
:type msg: :class:`aioxmpp.Message`
:return: The stanza token obtained from sending.
:rtype: :class:`~aioxmpp.stream.StanzaToken`
The default implementation simply calls :meth:`send_message_tracked`
and immediately cancels the tracking object, returning only the stanza
token.
There is no need to provide proper address attributes on `msg`.
Implementations will override those attributes with the values
appropriate for the conversation. Some implementations may allow the
user to choose a :attr:`~aioxmpp.Message.type_`, but others may simply
stamp it over.
Subclasses may override this method with a more specialised
implementation. Subclasses which do not provide tracked message sending
**must** override this method to provide untracked message sending.
.. seealso::
The corresponding feature is
:attr:`.ConversationFeature.SEND_MESSAGE`. See :attr:`features` for
details. | [
"Send",
"a",
"message",
"to",
"the",
"conversation",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/im/conversation.py#L680-L712 |
709 | horazont/aioxmpp | aioxmpp/im/conversation.py | AbstractConversation.invite | def invite(self, address, text=None, *,
mode=InviteMode.DIRECT,
allow_upgrade=False):
"""
Invite another entity to the conversation.
:param address: The address of the entity to invite.
:type address: :class:`aioxmpp.JID`
:param text: A reason/accompanying text for the invitation.
:param mode: The invitation mode to use.
:type mode: :class:`~.im.InviteMode`
:param allow_upgrade: Whether to allow creating a new conversation to
satisfy the invitation.
:type allow_upgrade: :class:`bool`
:raises NotImplementedError: if the requested `mode` is not supported
:raises ValueError: if `allow_upgrade` is false, but a new conversation
is required.
:return: The stanza token for the invitation and the possibly new
conversation object
:rtype: tuple of :class:`~.StanzaToken` and
:class:`~.AbstractConversation`
.. note::
Even though this is a coroutine, it returns a stanza token. The
coroutine-ness may be needed to generate the invitation in the
first place. Sending the actual invitation is done non-blockingly
and the stanza token for that is returned. To wait until the
invitation has been sent, unpack the stanza token from the result
and await it.
Return the new conversation object to use. In many cases, this will
simply be the current conversation object, but in some cases (e.g. when
someone is invited to a one-on-one conversation), a new conversation
must be created and used.
If `allow_upgrade` is false and a new conversation would be needed to
invite an entity, :class:`ValueError` is raised.
Additional features:
:attr:`~.ConversationFeature.INVITE_DIRECT`
Support for :attr:`~.im.InviteMode.DIRECT` mode.
:attr:`~.ConversationFeature.INVITE_DIRECT_CONFIGURE`
If a direct invitation is used, the conversation will be configured
to allow the invitee to join before the invitation is sent. This may
fail with a :class:`aioxmpp.errors.XMPPError`, in which case the
error is re-raised and the invitation not sent.
:attr:`~.ConversationFeature.INVITE_MEDIATED`
Support for :attr:`~.im.InviteMode.MEDIATED` mode.
:attr:`~.ConversationFeature.INVITE_UPGRADE`
If `allow_upgrade` is :data:`True`, an upgrade will be performed and
a new conversation is returned. If `allow_upgrade` is :data:`False`,
the invite will fail.
.. seealso::
The corresponding feature for this method is
:attr:`.ConversationFeature.INVITE`. See :attr:`features` for
details on the semantics of features.
"""
raise self._not_implemented_error("inviting entities") | python | def invite(self, address, text=None, *,
mode=InviteMode.DIRECT,
allow_upgrade=False):
raise self._not_implemented_error("inviting entities") | [
"def",
"invite",
"(",
"self",
",",
"address",
",",
"text",
"=",
"None",
",",
"*",
",",
"mode",
"=",
"InviteMode",
".",
"DIRECT",
",",
"allow_upgrade",
"=",
"False",
")",
":",
"raise",
"self",
".",
"_not_implemented_error",
"(",
"\"inviting entities\"",
")"
] | Invite another entity to the conversation.
:param address: The address of the entity to invite.
:type address: :class:`aioxmpp.JID`
:param text: A reason/accompanying text for the invitation.
:param mode: The invitation mode to use.
:type mode: :class:`~.im.InviteMode`
:param allow_upgrade: Whether to allow creating a new conversation to
satisfy the invitation.
:type allow_upgrade: :class:`bool`
:raises NotImplementedError: if the requested `mode` is not supported
:raises ValueError: if `allow_upgrade` is false, but a new conversation
is required.
:return: The stanza token for the invitation and the possibly new
conversation object
:rtype: tuple of :class:`~.StanzaToken` and
:class:`~.AbstractConversation`
.. note::
Even though this is a coroutine, it returns a stanza token. The
coroutine-ness may be needed to generate the invitation in the
first place. Sending the actual invitation is done non-blockingly
and the stanza token for that is returned. To wait until the
invitation has been sent, unpack the stanza token from the result
and await it.
Return the new conversation object to use. In many cases, this will
simply be the current conversation object, but in some cases (e.g. when
someone is invited to a one-on-one conversation), a new conversation
must be created and used.
If `allow_upgrade` is false and a new conversation would be needed to
invite an entity, :class:`ValueError` is raised.
Additional features:
:attr:`~.ConversationFeature.INVITE_DIRECT`
Support for :attr:`~.im.InviteMode.DIRECT` mode.
:attr:`~.ConversationFeature.INVITE_DIRECT_CONFIGURE`
If a direct invitation is used, the conversation will be configured
to allow the invitee to join before the invitation is sent. This may
fail with a :class:`aioxmpp.errors.XMPPError`, in which case the
error is re-raised and the invitation not sent.
:attr:`~.ConversationFeature.INVITE_MEDIATED`
Support for :attr:`~.im.InviteMode.MEDIATED` mode.
:attr:`~.ConversationFeature.INVITE_UPGRADE`
If `allow_upgrade` is :data:`True`, an upgrade will be performed and
a new conversation is returned. If `allow_upgrade` is :data:`False`,
the invite will fail.
.. seealso::
The corresponding feature for this method is
:attr:`.ConversationFeature.INVITE`. See :attr:`features` for
details on the semantics of features. | [
"Invite",
"another",
"entity",
"to",
"the",
"conversation",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/im/conversation.py#L809-L873 |
710 | horazont/aioxmpp | examples/xmpp_bridge.py | stdout_writer | async def stdout_writer():
"""
This is a bit complex, as stdout can be a pipe or a file.
If it is a file, we cannot use
:meth:`asycnio.BaseEventLoop.connect_write_pipe`.
"""
if sys.stdout.seekable():
# it’s a file
return sys.stdout.buffer.raw
if os.isatty(sys.stdin.fileno()):
# it’s a tty, use fd 0
fd_to_use = 0
else:
fd_to_use = 1
twrite, pwrite = await loop.connect_write_pipe(
asyncio.streams.FlowControlMixin,
os.fdopen(fd_to_use, "wb"),
)
swrite = asyncio.StreamWriter(
twrite,
pwrite,
None,
loop,
)
return swrite | python | async def stdout_writer():
if sys.stdout.seekable():
# it’s a file
return sys.stdout.buffer.raw
if os.isatty(sys.stdin.fileno()):
# it’s a tty, use fd 0
fd_to_use = 0
else:
fd_to_use = 1
twrite, pwrite = await loop.connect_write_pipe(
asyncio.streams.FlowControlMixin,
os.fdopen(fd_to_use, "wb"),
)
swrite = asyncio.StreamWriter(
twrite,
pwrite,
None,
loop,
)
return swrite | [
"async",
"def",
"stdout_writer",
"(",
")",
":",
"if",
"sys",
".",
"stdout",
".",
"seekable",
"(",
")",
":",
"# it’s a file",
"return",
"sys",
".",
"stdout",
".",
"buffer",
".",
"raw",
"if",
"os",
".",
"isatty",
"(",
"sys",
".",
"stdin",
".",
"fileno",
"(",
")",
")",
":",
"# it’s a tty, use fd 0",
"fd_to_use",
"=",
"0",
"else",
":",
"fd_to_use",
"=",
"1",
"twrite",
",",
"pwrite",
"=",
"await",
"loop",
".",
"connect_write_pipe",
"(",
"asyncio",
".",
"streams",
".",
"FlowControlMixin",
",",
"os",
".",
"fdopen",
"(",
"fd_to_use",
",",
"\"wb\"",
")",
",",
")",
"swrite",
"=",
"asyncio",
".",
"StreamWriter",
"(",
"twrite",
",",
"pwrite",
",",
"None",
",",
"loop",
",",
")",
"return",
"swrite"
] | This is a bit complex, as stdout can be a pipe or a file.
If it is a file, we cannot use
:meth:`asycnio.BaseEventLoop.connect_write_pipe`. | [
"This",
"is",
"a",
"bit",
"complex",
"as",
"stdout",
"can",
"be",
"a",
"pipe",
"or",
"a",
"file",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/examples/xmpp_bridge.py#L32-L61 |
711 | horazont/aioxmpp | aioxmpp/callbacks.py | first_signal | def first_signal(*signals):
"""
Connect to multiple signals and wait for the first to emit.
:param signals: Signals to connect to.
:type signals: :class:`AdHocSignal`
:return: An awaitable for the first signal to emit.
The awaitable returns the first argument passed to the signal. If the first
argument is an exception, the exception is re-raised from the awaitable.
A common use-case is a situation where a class exposes a "on_finished" type
signal and an "on_failure" type signal. :func:`first_signal` can be used
to combine those nicely::
# e.g. a aioxmpp.im.conversation.AbstractConversation
conversation = ...
await first_signal(
# emits without arguments when the conversation is successfully
# entered
conversation.on_enter,
# emits with an exception when entering the conversation fails
conversation.on_failure,
)
# await first_signal(...) will either raise an exception (failed) or
# return None (success)
.. warning::
Only works with signals which emit with zero or one argument. Signals
which emit with more than one argument or with keyword arguments are
silently ignored! (Thus, if only such signals are connected, the
future will never complete.)
(This is a side-effect of the implementation of
:meth:`AdHocSignal.AUTO_FUTURE`).
.. note::
Does not work with coroutine signals (:class:`SyncAdHocSignal`).
"""
fut = asyncio.Future()
for signal in signals:
signal.connect(fut, signal.AUTO_FUTURE)
return fut | python | def first_signal(*signals):
fut = asyncio.Future()
for signal in signals:
signal.connect(fut, signal.AUTO_FUTURE)
return fut | [
"def",
"first_signal",
"(",
"*",
"signals",
")",
":",
"fut",
"=",
"asyncio",
".",
"Future",
"(",
")",
"for",
"signal",
"in",
"signals",
":",
"signal",
".",
"connect",
"(",
"fut",
",",
"signal",
".",
"AUTO_FUTURE",
")",
"return",
"fut"
] | Connect to multiple signals and wait for the first to emit.
:param signals: Signals to connect to.
:type signals: :class:`AdHocSignal`
:return: An awaitable for the first signal to emit.
The awaitable returns the first argument passed to the signal. If the first
argument is an exception, the exception is re-raised from the awaitable.
A common use-case is a situation where a class exposes a "on_finished" type
signal and an "on_failure" type signal. :func:`first_signal` can be used
to combine those nicely::
# e.g. a aioxmpp.im.conversation.AbstractConversation
conversation = ...
await first_signal(
# emits without arguments when the conversation is successfully
# entered
conversation.on_enter,
# emits with an exception when entering the conversation fails
conversation.on_failure,
)
# await first_signal(...) will either raise an exception (failed) or
# return None (success)
.. warning::
Only works with signals which emit with zero or one argument. Signals
which emit with more than one argument or with keyword arguments are
silently ignored! (Thus, if only such signals are connected, the
future will never complete.)
(This is a side-effect of the implementation of
:meth:`AdHocSignal.AUTO_FUTURE`).
.. note::
Does not work with coroutine signals (:class:`SyncAdHocSignal`). | [
"Connect",
"to",
"multiple",
"signals",
"and",
"wait",
"for",
"the",
"first",
"to",
"emit",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L853-L898 |
712 | horazont/aioxmpp | aioxmpp/callbacks.py | AdHocSignal.connect | def connect(self, f, mode=None):
"""
Connect an object `f` to the signal. The type the object needs to have
depends on `mode`, but usually it needs to be a callable.
:meth:`connect` returns an opaque token which can be used with
:meth:`disconnect` to disconnect the object from the signal.
The default value for `mode` is :attr:`STRONG`. Any decorator can be
used as argument for `mode` and it is applied to `f`. The result is
stored internally and is what will be called when the signal is being
emitted.
If the result of `mode` returns a false value during emission, the
connection is removed.
.. note::
The return values required by the callable returned by `mode` and
the one required by a callable passed to `f` using the predefined
modes are complementary!
A callable `f` needs to return true to be removed from the
connections, while a callable returned by the `mode` decorator needs
to return false.
Existing modes are listed below.
"""
mode = mode or self.STRONG
self.logger.debug("connecting %r with mode %r", f, mode)
return self._connect(mode(f)) | python | def connect(self, f, mode=None):
mode = mode or self.STRONG
self.logger.debug("connecting %r with mode %r", f, mode)
return self._connect(mode(f)) | [
"def",
"connect",
"(",
"self",
",",
"f",
",",
"mode",
"=",
"None",
")",
":",
"mode",
"=",
"mode",
"or",
"self",
".",
"STRONG",
"self",
".",
"logger",
".",
"debug",
"(",
"\"connecting %r with mode %r\"",
",",
"f",
",",
"mode",
")",
"return",
"self",
".",
"_connect",
"(",
"mode",
"(",
"f",
")",
")"
] | Connect an object `f` to the signal. The type the object needs to have
depends on `mode`, but usually it needs to be a callable.
:meth:`connect` returns an opaque token which can be used with
:meth:`disconnect` to disconnect the object from the signal.
The default value for `mode` is :attr:`STRONG`. Any decorator can be
used as argument for `mode` and it is applied to `f`. The result is
stored internally and is what will be called when the signal is being
emitted.
If the result of `mode` returns a false value during emission, the
connection is removed.
.. note::
The return values required by the callable returned by `mode` and
the one required by a callable passed to `f` using the predefined
modes are complementary!
A callable `f` needs to return true to be removed from the
connections, while a callable returned by the `mode` decorator needs
to return false.
Existing modes are listed below. | [
"Connect",
"an",
"object",
"f",
"to",
"the",
"signal",
".",
"The",
"type",
"the",
"object",
"needs",
"to",
"have",
"depends",
"on",
"mode",
"but",
"usually",
"it",
"needs",
"to",
"be",
"a",
"callable",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L472-L503 |
713 | horazont/aioxmpp | aioxmpp/callbacks.py | AdHocSignal.fire | def fire(self, *args, **kwargs):
"""
Emit the signal, calling all connected objects in-line with the given
arguments and in the order they were registered.
:class:`AdHocSignal` provides full isolation with respect to
exceptions. If a connected listener raises an exception, the other
listeners are executed as normal, but the raising listener is removed
from the signal. The exception is logged to :attr:`logger` and *not*
re-raised, so that the caller of the signal is also not affected.
Instead of calling :meth:`fire` explicitly, the ad-hoc signal object
itself can be called, too.
"""
for token, wrapper in list(self._connections.items()):
try:
keep = wrapper(args, kwargs)
except Exception:
self.logger.exception("listener attached to signal raised")
keep = False
if not keep:
del self._connections[token] | python | def fire(self, *args, **kwargs):
for token, wrapper in list(self._connections.items()):
try:
keep = wrapper(args, kwargs)
except Exception:
self.logger.exception("listener attached to signal raised")
keep = False
if not keep:
del self._connections[token] | [
"def",
"fire",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"token",
",",
"wrapper",
"in",
"list",
"(",
"self",
".",
"_connections",
".",
"items",
"(",
")",
")",
":",
"try",
":",
"keep",
"=",
"wrapper",
"(",
"args",
",",
"kwargs",
")",
"except",
"Exception",
":",
"self",
".",
"logger",
".",
"exception",
"(",
"\"listener attached to signal raised\"",
")",
"keep",
"=",
"False",
"if",
"not",
"keep",
":",
"del",
"self",
".",
"_connections",
"[",
"token",
"]"
] | Emit the signal, calling all connected objects in-line with the given
arguments and in the order they were registered.
:class:`AdHocSignal` provides full isolation with respect to
exceptions. If a connected listener raises an exception, the other
listeners are executed as normal, but the raising listener is removed
from the signal. The exception is logged to :attr:`logger` and *not*
re-raised, so that the caller of the signal is also not affected.
Instead of calling :meth:`fire` explicitly, the ad-hoc signal object
itself can be called, too. | [
"Emit",
"the",
"signal",
"calling",
"all",
"connected",
"objects",
"in",
"-",
"line",
"with",
"the",
"given",
"arguments",
"and",
"in",
"the",
"order",
"they",
"were",
"registered",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L520-L541 |
714 | horazont/aioxmpp | aioxmpp/callbacks.py | SyncAdHocSignal.connect | def connect(self, coro):
"""
The coroutine `coro` is connected to the signal. The coroutine must
return a true value, unless it wants to be disconnected from the
signal.
.. note::
This is different from the return value convention with
:attr:`AdHocSignal.STRONG` and :attr:`AdHocSignal.WEAK`.
:meth:`connect` returns a token which can be used with
:meth:`disconnect` to disconnect the coroutine.
"""
self.logger.debug("connecting %r", coro)
return self._connect(coro) | python | def connect(self, coro):
self.logger.debug("connecting %r", coro)
return self._connect(coro) | [
"def",
"connect",
"(",
"self",
",",
"coro",
")",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"connecting %r\"",
",",
"coro",
")",
"return",
"self",
".",
"_connect",
"(",
"coro",
")"
] | The coroutine `coro` is connected to the signal. The coroutine must
return a true value, unless it wants to be disconnected from the
signal.
.. note::
This is different from the return value convention with
:attr:`AdHocSignal.STRONG` and :attr:`AdHocSignal.WEAK`.
:meth:`connect` returns a token which can be used with
:meth:`disconnect` to disconnect the coroutine. | [
"The",
"coroutine",
"coro",
"is",
"connected",
"to",
"the",
"signal",
".",
"The",
"coroutine",
"must",
"return",
"a",
"true",
"value",
"unless",
"it",
"wants",
"to",
"be",
"disconnected",
"from",
"the",
"signal",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L572-L587 |
715 | horazont/aioxmpp | aioxmpp/callbacks.py | SyncAdHocSignal.fire | def fire(self, *args, **kwargs):
"""
Emit the signal, calling all coroutines in-line with the given
arguments and in the order they were registered.
This is obviously a coroutine.
Instead of calling :meth:`fire` explicitly, the ad-hoc signal object
itself can be called, too.
"""
for token, coro in list(self._connections.items()):
keep = yield from coro(*args, **kwargs)
if not keep:
del self._connections[token] | python | def fire(self, *args, **kwargs):
for token, coro in list(self._connections.items()):
keep = yield from coro(*args, **kwargs)
if not keep:
del self._connections[token] | [
"def",
"fire",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"token",
",",
"coro",
"in",
"list",
"(",
"self",
".",
"_connections",
".",
"items",
"(",
")",
")",
":",
"keep",
"=",
"yield",
"from",
"coro",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"not",
"keep",
":",
"del",
"self",
".",
"_connections",
"[",
"token",
"]"
] | Emit the signal, calling all coroutines in-line with the given
arguments and in the order they were registered.
This is obviously a coroutine.
Instead of calling :meth:`fire` explicitly, the ad-hoc signal object
itself can be called, too. | [
"Emit",
"the",
"signal",
"calling",
"all",
"coroutines",
"in",
"-",
"line",
"with",
"the",
"given",
"arguments",
"and",
"in",
"the",
"order",
"they",
"were",
"registered",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L605-L618 |
716 | horazont/aioxmpp | aioxmpp/callbacks.py | Filter.register | def register(self, func, order):
"""
Add a function to the filter chain.
:param func: A callable which is to be added to the filter chain.
:param order: An object indicating the ordering of the function
relative to the others.
:return: Token representing the registration.
Register the function `func` as a filter into the chain. `order` must
be a value which is used as a sorting key to order the functions
registered in the chain.
The type of `order` depends on the use of the filter, as does the
number of arguments and keyword arguments which `func` must accept.
This will generally be documented at the place where the
:class:`Filter` is used.
Functions with the same order are sorted in the order of their
addition, with the function which was added earliest first.
Remember that all values passed to `order` which are registered at the
same time in the same :class:`Filter` need to be totally orderable with
respect to each other.
The returned token can be used to :meth:`unregister` a filter.
"""
token = self.Token()
self._filter_order.append((order, token, func))
self._filter_order.sort(key=lambda x: x[0])
return token | python | def register(self, func, order):
token = self.Token()
self._filter_order.append((order, token, func))
self._filter_order.sort(key=lambda x: x[0])
return token | [
"def",
"register",
"(",
"self",
",",
"func",
",",
"order",
")",
":",
"token",
"=",
"self",
".",
"Token",
"(",
")",
"self",
".",
"_filter_order",
".",
"append",
"(",
"(",
"order",
",",
"token",
",",
"func",
")",
")",
"self",
".",
"_filter_order",
".",
"sort",
"(",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
")",
"return",
"token"
] | Add a function to the filter chain.
:param func: A callable which is to be added to the filter chain.
:param order: An object indicating the ordering of the function
relative to the others.
:return: Token representing the registration.
Register the function `func` as a filter into the chain. `order` must
be a value which is used as a sorting key to order the functions
registered in the chain.
The type of `order` depends on the use of the filter, as does the
number of arguments and keyword arguments which `func` must accept.
This will generally be documented at the place where the
:class:`Filter` is used.
Functions with the same order are sorted in the order of their
addition, with the function which was added earliest first.
Remember that all values passed to `order` which are registered at the
same time in the same :class:`Filter` need to be totally orderable with
respect to each other.
The returned token can be used to :meth:`unregister` a filter. | [
"Add",
"a",
"function",
"to",
"the",
"filter",
"chain",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L758-L788 |
717 | horazont/aioxmpp | aioxmpp/callbacks.py | Filter.filter | def filter(self, obj, *args, **kwargs):
"""
Filter the given object through the filter chain.
:param obj: The object to filter
:param args: Additional arguments to pass to each filter function.
:param kwargs: Additional keyword arguments to pass to each filter
function.
:return: The filtered object or :data:`None`
See the documentation of :class:`Filter` on how filtering operates.
Returns the object returned by the last function in the filter chain or
:data:`None` if any function returned :data:`None`.
"""
for _, _, func in self._filter_order:
obj = func(obj, *args, **kwargs)
if obj is None:
return None
return obj | python | def filter(self, obj, *args, **kwargs):
for _, _, func in self._filter_order:
obj = func(obj, *args, **kwargs)
if obj is None:
return None
return obj | [
"def",
"filter",
"(",
"self",
",",
"obj",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"_",
",",
"_",
",",
"func",
"in",
"self",
".",
"_filter_order",
":",
"obj",
"=",
"func",
"(",
"obj",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"obj",
"is",
"None",
":",
"return",
"None",
"return",
"obj"
] | Filter the given object through the filter chain.
:param obj: The object to filter
:param args: Additional arguments to pass to each filter function.
:param kwargs: Additional keyword arguments to pass to each filter
function.
:return: The filtered object or :data:`None`
See the documentation of :class:`Filter` on how filtering operates.
Returns the object returned by the last function in the filter chain or
:data:`None` if any function returned :data:`None`. | [
"Filter",
"the",
"given",
"object",
"through",
"the",
"filter",
"chain",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L790-L809 |
718 | horazont/aioxmpp | aioxmpp/callbacks.py | Filter.unregister | def unregister(self, token_to_remove):
"""
Unregister a filter function.
:param token_to_remove: The token as returned by :meth:`register`.
Unregister a function from the filter chain using the token returned by
:meth:`register`.
"""
for i, (_, token, _) in enumerate(self._filter_order):
if token == token_to_remove:
break
else:
raise ValueError("unregistered token: {!r}".format(
token_to_remove))
del self._filter_order[i] | python | def unregister(self, token_to_remove):
for i, (_, token, _) in enumerate(self._filter_order):
if token == token_to_remove:
break
else:
raise ValueError("unregistered token: {!r}".format(
token_to_remove))
del self._filter_order[i] | [
"def",
"unregister",
"(",
"self",
",",
"token_to_remove",
")",
":",
"for",
"i",
",",
"(",
"_",
",",
"token",
",",
"_",
")",
"in",
"enumerate",
"(",
"self",
".",
"_filter_order",
")",
":",
"if",
"token",
"==",
"token_to_remove",
":",
"break",
"else",
":",
"raise",
"ValueError",
"(",
"\"unregistered token: {!r}\"",
".",
"format",
"(",
"token_to_remove",
")",
")",
"del",
"self",
".",
"_filter_order",
"[",
"i",
"]"
] | Unregister a filter function.
:param token_to_remove: The token as returned by :meth:`register`.
Unregister a function from the filter chain using the token returned by
:meth:`register`. | [
"Unregister",
"a",
"filter",
"function",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/callbacks.py#L811-L826 |
719 | horazont/aioxmpp | aioxmpp/tracking.py | MessageTracker.set_timeout | def set_timeout(self, timeout):
"""
Automatically close the tracker after `timeout` has elapsed.
:param timeout: The timeout after which the tracker is closed
automatically.
:type timeout: :class:`numbers.Real` or :class:`datetime.timedelta`
If the `timeout` is not a :class:`datetime.timedelta` instance, it is
assumed to be given as seconds.
The timeout cannot be cancelled after it has been set. It starts at the
very moment :meth:`set_timeout` is called.
"""
loop = asyncio.get_event_loop()
if isinstance(timeout, timedelta):
timeout = timeout.total_seconds()
loop.call_later(timeout, self.close) | python | def set_timeout(self, timeout):
loop = asyncio.get_event_loop()
if isinstance(timeout, timedelta):
timeout = timeout.total_seconds()
loop.call_later(timeout, self.close) | [
"def",
"set_timeout",
"(",
"self",
",",
"timeout",
")",
":",
"loop",
"=",
"asyncio",
".",
"get_event_loop",
"(",
")",
"if",
"isinstance",
"(",
"timeout",
",",
"timedelta",
")",
":",
"timeout",
"=",
"timeout",
".",
"total_seconds",
"(",
")",
"loop",
".",
"call_later",
"(",
"timeout",
",",
"self",
".",
"close",
")"
] | Automatically close the tracker after `timeout` has elapsed.
:param timeout: The timeout after which the tracker is closed
automatically.
:type timeout: :class:`numbers.Real` or :class:`datetime.timedelta`
If the `timeout` is not a :class:`datetime.timedelta` instance, it is
assumed to be given as seconds.
The timeout cannot be cancelled after it has been set. It starts at the
very moment :meth:`set_timeout` is called. | [
"Automatically",
"close",
"the",
"tracker",
"after",
"timeout",
"has",
"elapsed",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/tracking.py#L269-L288 |
720 | horazont/aioxmpp | aioxmpp/tracking.py | MessageTracker._set_state | def _set_state(self, new_state, response=None):
"""
Set the state of the tracker.
:param new_state: The new state of the tracker.
:type new_state: :class:`~.MessageState` member
:param response: A stanza related to the new state.
:type response: :class:`~.StanzaBase` or :data:`None`
:raise ValueError: if a forbidden state transition is attempted.
:raise RuntimeError: if the tracker is closed.
The state of the tracker is set to the `new_state`. The
:attr:`response` is also overriden with the new value, no matter if the
new or old value is :data:`None` or not. The :meth:`on_state_changed`
event is emitted.
The following transitions are forbidden and attempting to perform them
will raise :class:`ValueError`:
* any state -> :attr:`~.MessageState.IN_TRANSIT`
* :attr:`~.MessageState.DELIVERED_TO_RECIPIENT` ->
:attr:`~.MessageState.DELIVERED_TO_SERVER`
* :attr:`~.MessageState.SEEN_BY_RECIPIENT` ->
:attr:`~.MessageState.DELIVERED_TO_RECIPIENT`
* :attr:`~.MessageState.SEEN_BY_RECIPIENT` ->
:attr:`~.MessageState.DELIVERED_TO_SERVER`
* :attr:`~.MessageState.ABORTED` -> any state
* :attr:`~.MessageState.ERROR` -> any state
If the tracker is already :meth:`close`\\ -d, :class:`RuntimeError` is
raised. This check happens *before* a test is made whether the
transition is valid.
This method is part of the "protected" interface.
"""
if self._closed:
raise RuntimeError("message tracker is closed")
# reject some transitions as documented
if (self._state == MessageState.ABORTED or
new_state == MessageState.IN_TRANSIT or
(self._state == MessageState.ERROR and
new_state == MessageState.DELIVERED_TO_SERVER) or
(self._state == MessageState.ERROR and
new_state == MessageState.ABORTED) or
(self._state == MessageState.DELIVERED_TO_RECIPIENT and
new_state == MessageState.DELIVERED_TO_SERVER) or
(self._state == MessageState.SEEN_BY_RECIPIENT and
new_state == MessageState.DELIVERED_TO_SERVER) or
(self._state == MessageState.SEEN_BY_RECIPIENT and
new_state == MessageState.DELIVERED_TO_RECIPIENT)):
raise ValueError(
"message tracker transition from {} to {} not allowed".format(
self._state,
new_state
)
)
self._state = new_state
self._response = response
self.on_state_changed(self._state, self._response) | python | def _set_state(self, new_state, response=None):
if self._closed:
raise RuntimeError("message tracker is closed")
# reject some transitions as documented
if (self._state == MessageState.ABORTED or
new_state == MessageState.IN_TRANSIT or
(self._state == MessageState.ERROR and
new_state == MessageState.DELIVERED_TO_SERVER) or
(self._state == MessageState.ERROR and
new_state == MessageState.ABORTED) or
(self._state == MessageState.DELIVERED_TO_RECIPIENT and
new_state == MessageState.DELIVERED_TO_SERVER) or
(self._state == MessageState.SEEN_BY_RECIPIENT and
new_state == MessageState.DELIVERED_TO_SERVER) or
(self._state == MessageState.SEEN_BY_RECIPIENT and
new_state == MessageState.DELIVERED_TO_RECIPIENT)):
raise ValueError(
"message tracker transition from {} to {} not allowed".format(
self._state,
new_state
)
)
self._state = new_state
self._response = response
self.on_state_changed(self._state, self._response) | [
"def",
"_set_state",
"(",
"self",
",",
"new_state",
",",
"response",
"=",
"None",
")",
":",
"if",
"self",
".",
"_closed",
":",
"raise",
"RuntimeError",
"(",
"\"message tracker is closed\"",
")",
"# reject some transitions as documented",
"if",
"(",
"self",
".",
"_state",
"==",
"MessageState",
".",
"ABORTED",
"or",
"new_state",
"==",
"MessageState",
".",
"IN_TRANSIT",
"or",
"(",
"self",
".",
"_state",
"==",
"MessageState",
".",
"ERROR",
"and",
"new_state",
"==",
"MessageState",
".",
"DELIVERED_TO_SERVER",
")",
"or",
"(",
"self",
".",
"_state",
"==",
"MessageState",
".",
"ERROR",
"and",
"new_state",
"==",
"MessageState",
".",
"ABORTED",
")",
"or",
"(",
"self",
".",
"_state",
"==",
"MessageState",
".",
"DELIVERED_TO_RECIPIENT",
"and",
"new_state",
"==",
"MessageState",
".",
"DELIVERED_TO_SERVER",
")",
"or",
"(",
"self",
".",
"_state",
"==",
"MessageState",
".",
"SEEN_BY_RECIPIENT",
"and",
"new_state",
"==",
"MessageState",
".",
"DELIVERED_TO_SERVER",
")",
"or",
"(",
"self",
".",
"_state",
"==",
"MessageState",
".",
"SEEN_BY_RECIPIENT",
"and",
"new_state",
"==",
"MessageState",
".",
"DELIVERED_TO_RECIPIENT",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"message tracker transition from {} to {} not allowed\"",
".",
"format",
"(",
"self",
".",
"_state",
",",
"new_state",
")",
")",
"self",
".",
"_state",
"=",
"new_state",
"self",
".",
"_response",
"=",
"response",
"self",
".",
"on_state_changed",
"(",
"self",
".",
"_state",
",",
"self",
".",
"_response",
")"
] | Set the state of the tracker.
:param new_state: The new state of the tracker.
:type new_state: :class:`~.MessageState` member
:param response: A stanza related to the new state.
:type response: :class:`~.StanzaBase` or :data:`None`
:raise ValueError: if a forbidden state transition is attempted.
:raise RuntimeError: if the tracker is closed.
The state of the tracker is set to the `new_state`. The
:attr:`response` is also overriden with the new value, no matter if the
new or old value is :data:`None` or not. The :meth:`on_state_changed`
event is emitted.
The following transitions are forbidden and attempting to perform them
will raise :class:`ValueError`:
* any state -> :attr:`~.MessageState.IN_TRANSIT`
* :attr:`~.MessageState.DELIVERED_TO_RECIPIENT` ->
:attr:`~.MessageState.DELIVERED_TO_SERVER`
* :attr:`~.MessageState.SEEN_BY_RECIPIENT` ->
:attr:`~.MessageState.DELIVERED_TO_RECIPIENT`
* :attr:`~.MessageState.SEEN_BY_RECIPIENT` ->
:attr:`~.MessageState.DELIVERED_TO_SERVER`
* :attr:`~.MessageState.ABORTED` -> any state
* :attr:`~.MessageState.ERROR` -> any state
If the tracker is already :meth:`close`\\ -d, :class:`RuntimeError` is
raised. This check happens *before* a test is made whether the
transition is valid.
This method is part of the "protected" interface. | [
"Set",
"the",
"state",
"of",
"the",
"tracker",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/tracking.py#L292-L352 |
721 | horazont/aioxmpp | aioxmpp/tracking.py | BasicTrackingService.send_tracked | def send_tracked(self, stanza, tracker):
"""
Send a message stanza with tracking.
:param stanza: Message stanza to send.
:type stanza: :class:`aioxmpp.Message`
:param tracker: Message tracker to use.
:type tracker: :class:`~.MessageTracker`
:rtype: :class:`~.StanzaToken`
:return: The token used to send the stanza.
If `tracker` is :data:`None`, a new :class:`~.MessageTracker` is
created.
This configures tracking for the stanza as if by calling
:meth:`attach_tracker` with a `token` and sends the stanza through the
stream.
.. seealso::
:meth:`attach_tracker`
can be used if the stanza cannot be sent (e.g. because it is a
carbon-copy) or has already been sent.
"""
token = self.client.enqueue(stanza)
self.attach_tracker(stanza, tracker, token)
return token | python | def send_tracked(self, stanza, tracker):
token = self.client.enqueue(stanza)
self.attach_tracker(stanza, tracker, token)
return token | [
"def",
"send_tracked",
"(",
"self",
",",
"stanza",
",",
"tracker",
")",
":",
"token",
"=",
"self",
".",
"client",
".",
"enqueue",
"(",
"stanza",
")",
"self",
".",
"attach_tracker",
"(",
"stanza",
",",
"tracker",
",",
"token",
")",
"return",
"token"
] | Send a message stanza with tracking.
:param stanza: Message stanza to send.
:type stanza: :class:`aioxmpp.Message`
:param tracker: Message tracker to use.
:type tracker: :class:`~.MessageTracker`
:rtype: :class:`~.StanzaToken`
:return: The token used to send the stanza.
If `tracker` is :data:`None`, a new :class:`~.MessageTracker` is
created.
This configures tracking for the stanza as if by calling
:meth:`attach_tracker` with a `token` and sends the stanza through the
stream.
.. seealso::
:meth:`attach_tracker`
can be used if the stanza cannot be sent (e.g. because it is a
carbon-copy) or has already been sent. | [
"Send",
"a",
"message",
"stanza",
"with",
"tracking",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/tracking.py#L425-L451 |
722 | horazont/aioxmpp | aioxmpp/tracking.py | BasicTrackingService.attach_tracker | def attach_tracker(self, stanza, tracker=None, token=None):
"""
Configure tracking for a stanza without sending it.
:param stanza: Message stanza to send.
:type stanza: :class:`aioxmpp.Message`
:param tracker: Message tracker to use.
:type tracker: :class:`~.MessageTracker` or :data:`None`
:param token: Optional stanza token for more fine-grained tracking.
:type token: :class:`~.StanzaToken`
:rtype: :class:`~.MessageTracker`
:return: The message tracker.
If `tracker` is :data:`None`, a new :class:`~.MessageTracker` is
created.
If `token` is not :data:`None`, updates to the stanza `token` are
reflected in the `tracker`.
If an error reply is received, the tracker will enter
:class:`~.MessageState.ERROR` and the error will be set as
:attr:`~.MessageTracker.response`.
You should use :meth:`send_tracked` if possible. This method however is
very useful if you need to track carbon copies of sent messages, as a
stanza token is not available here and re-sending the message to obtain
one is generally not desirable ☺.
"""
if tracker is None:
tracker = MessageTracker()
stanza.autoset_id()
key = stanza.to.bare(), stanza.id_
self._trackers[key] = tracker
tracker.on_closed.connect(
functools.partial(self._tracker_closed, key)
)
if token is not None:
token.future.add_done_callback(
functools.partial(
self._stanza_sent,
tracker,
token,
)
)
return tracker | python | def attach_tracker(self, stanza, tracker=None, token=None):
if tracker is None:
tracker = MessageTracker()
stanza.autoset_id()
key = stanza.to.bare(), stanza.id_
self._trackers[key] = tracker
tracker.on_closed.connect(
functools.partial(self._tracker_closed, key)
)
if token is not None:
token.future.add_done_callback(
functools.partial(
self._stanza_sent,
tracker,
token,
)
)
return tracker | [
"def",
"attach_tracker",
"(",
"self",
",",
"stanza",
",",
"tracker",
"=",
"None",
",",
"token",
"=",
"None",
")",
":",
"if",
"tracker",
"is",
"None",
":",
"tracker",
"=",
"MessageTracker",
"(",
")",
"stanza",
".",
"autoset_id",
"(",
")",
"key",
"=",
"stanza",
".",
"to",
".",
"bare",
"(",
")",
",",
"stanza",
".",
"id_",
"self",
".",
"_trackers",
"[",
"key",
"]",
"=",
"tracker",
"tracker",
".",
"on_closed",
".",
"connect",
"(",
"functools",
".",
"partial",
"(",
"self",
".",
"_tracker_closed",
",",
"key",
")",
")",
"if",
"token",
"is",
"not",
"None",
":",
"token",
".",
"future",
".",
"add_done_callback",
"(",
"functools",
".",
"partial",
"(",
"self",
".",
"_stanza_sent",
",",
"tracker",
",",
"token",
",",
")",
")",
"return",
"tracker"
] | Configure tracking for a stanza without sending it.
:param stanza: Message stanza to send.
:type stanza: :class:`aioxmpp.Message`
:param tracker: Message tracker to use.
:type tracker: :class:`~.MessageTracker` or :data:`None`
:param token: Optional stanza token for more fine-grained tracking.
:type token: :class:`~.StanzaToken`
:rtype: :class:`~.MessageTracker`
:return: The message tracker.
If `tracker` is :data:`None`, a new :class:`~.MessageTracker` is
created.
If `token` is not :data:`None`, updates to the stanza `token` are
reflected in the `tracker`.
If an error reply is received, the tracker will enter
:class:`~.MessageState.ERROR` and the error will be set as
:attr:`~.MessageTracker.response`.
You should use :meth:`send_tracked` if possible. This method however is
very useful if you need to track carbon copies of sent messages, as a
stanza token is not available here and re-sending the message to obtain
one is generally not desirable ☺. | [
"Configure",
"tracking",
"for",
"a",
"stanza",
"without",
"sending",
"it",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/tracking.py#L453-L497 |
723 | horazont/aioxmpp | aioxmpp/muc/self_ping.py | MUCPinger.start | def start(self):
"""
Start the pinging coroutine using the client and event loop which was
passed to the constructor.
:meth:`start` always behaves as if :meth:`stop` was called right before
it.
"""
self.stop()
self._task = asyncio.ensure_future(self._pinger(), loop=self._loop) | python | def start(self):
self.stop()
self._task = asyncio.ensure_future(self._pinger(), loop=self._loop) | [
"def",
"start",
"(",
"self",
")",
":",
"self",
".",
"stop",
"(",
")",
"self",
".",
"_task",
"=",
"asyncio",
".",
"ensure_future",
"(",
"self",
".",
"_pinger",
"(",
")",
",",
"loop",
"=",
"self",
".",
"_loop",
")"
] | Start the pinging coroutine using the client and event loop which was
passed to the constructor.
:meth:`start` always behaves as if :meth:`stop` was called right before
it. | [
"Start",
"the",
"pinging",
"coroutine",
"using",
"the",
"client",
"and",
"event",
"loop",
"which",
"was",
"passed",
"to",
"the",
"constructor",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/muc/self_ping.py#L131-L140 |
724 | horazont/aioxmpp | aioxmpp/muc/self_ping.py | MUCPinger._interpret_result | def _interpret_result(self, task):
"""
Interpret the result of a ping.
:param task: The pinger task.
The result or exception of the `task` is interpreted as follows:
* :data:`None` result: *positive*
* :class:`aioxmpp.errors.XMPPError`, ``service-unavailable``:
*positive*
* :class:`aioxmpp.errors.XMPPError`, ``feature-not-implemented``:
*positive*
* :class:`aioxmpp.errors.XMPPError`, ``item-not-found``: *inconclusive*
* :class:`aioxmpp.errors.XMPPError`: *negative*
* :class:`asyncio.TimeoutError`: *inconclusive*
* Any other exception: *inconclusive*
"""
if task.exception() is None:
self._on_fresh()
return
exc = task.exception()
if isinstance(exc, aioxmpp.errors.XMPPError):
if exc.condition in [
aioxmpp.errors.ErrorCondition.SERVICE_UNAVAILABLE,
aioxmpp.errors.ErrorCondition.FEATURE_NOT_IMPLEMENTED]:
self._on_fresh()
return
if exc.condition == aioxmpp.errors.ErrorCondition.ITEM_NOT_FOUND:
return
self._on_exited() | python | def _interpret_result(self, task):
if task.exception() is None:
self._on_fresh()
return
exc = task.exception()
if isinstance(exc, aioxmpp.errors.XMPPError):
if exc.condition in [
aioxmpp.errors.ErrorCondition.SERVICE_UNAVAILABLE,
aioxmpp.errors.ErrorCondition.FEATURE_NOT_IMPLEMENTED]:
self._on_fresh()
return
if exc.condition == aioxmpp.errors.ErrorCondition.ITEM_NOT_FOUND:
return
self._on_exited() | [
"def",
"_interpret_result",
"(",
"self",
",",
"task",
")",
":",
"if",
"task",
".",
"exception",
"(",
")",
"is",
"None",
":",
"self",
".",
"_on_fresh",
"(",
")",
"return",
"exc",
"=",
"task",
".",
"exception",
"(",
")",
"if",
"isinstance",
"(",
"exc",
",",
"aioxmpp",
".",
"errors",
".",
"XMPPError",
")",
":",
"if",
"exc",
".",
"condition",
"in",
"[",
"aioxmpp",
".",
"errors",
".",
"ErrorCondition",
".",
"SERVICE_UNAVAILABLE",
",",
"aioxmpp",
".",
"errors",
".",
"ErrorCondition",
".",
"FEATURE_NOT_IMPLEMENTED",
"]",
":",
"self",
".",
"_on_fresh",
"(",
")",
"return",
"if",
"exc",
".",
"condition",
"==",
"aioxmpp",
".",
"errors",
".",
"ErrorCondition",
".",
"ITEM_NOT_FOUND",
":",
"return",
"self",
".",
"_on_exited",
"(",
")"
] | Interpret the result of a ping.
:param task: The pinger task.
The result or exception of the `task` is interpreted as follows:
* :data:`None` result: *positive*
* :class:`aioxmpp.errors.XMPPError`, ``service-unavailable``:
*positive*
* :class:`aioxmpp.errors.XMPPError`, ``feature-not-implemented``:
*positive*
* :class:`aioxmpp.errors.XMPPError`, ``item-not-found``: *inconclusive*
* :class:`aioxmpp.errors.XMPPError`: *negative*
* :class:`asyncio.TimeoutError`: *inconclusive*
* Any other exception: *inconclusive* | [
"Interpret",
"the",
"result",
"of",
"a",
"ping",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/muc/self_ping.py#L156-L189 |
725 | horazont/aioxmpp | aioxmpp/muc/self_ping.py | MUCMonitor.reset | def reset(self):
"""
Reset the monitor.
Reset the aliveness timeouts. Clear the stale state. Cancel and stop
pinging.
Call `on_fresh` if the stale state was set.
"""
self._monitor.notify_received()
self._pinger.stop()
self._mark_fresh() | python | def reset(self):
self._monitor.notify_received()
self._pinger.stop()
self._mark_fresh() | [
"def",
"reset",
"(",
"self",
")",
":",
"self",
".",
"_monitor",
".",
"notify_received",
"(",
")",
"self",
".",
"_pinger",
".",
"stop",
"(",
")",
"self",
".",
"_mark_fresh",
"(",
")"
] | Reset the monitor.
Reset the aliveness timeouts. Clear the stale state. Cancel and stop
pinging.
Call `on_fresh` if the stale state was set. | [
"Reset",
"the",
"monitor",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/muc/self_ping.py#L378-L389 |
726 | horazont/aioxmpp | aioxmpp/mdr/service.py | DeliveryReceiptsService.attach_tracker | def attach_tracker(self, stanza, tracker=None):
"""
Return a new tracker or modify one to track the stanza.
:param stanza: Stanza to track.
:type stanza: :class:`aioxmpp.Message`
:param tracker: Existing tracker to attach to.
:type tracker: :class:`.tracking.MessageTracker`
:raises ValueError: if the stanza is of type
:attr:`~aioxmpp.MessageType.ERROR`
:raises ValueError: if the stanza contains a delivery receipt
:return: The message tracker for the stanza.
:rtype: :class:`.tracking.MessageTracker`
The `stanza` gets a :xep:`184` reciept request attached and internal
handlers are set up to update the `tracker` state once a confirmation
is received.
.. warning::
See the :ref:`api-tracking-memory`.
"""
if stanza.xep0184_received is not None:
raise ValueError(
"requesting delivery receipts for delivery receipts is not "
"allowed"
)
if stanza.type_ == aioxmpp.MessageType.ERROR:
raise ValueError(
"requesting delivery receipts for errors is not supported"
)
if tracker is None:
tracker = aioxmpp.tracking.MessageTracker()
stanza.xep0184_request_receipt = True
stanza.autoset_id()
self._bare_jid_maps[stanza.to, stanza.id_] = tracker
return tracker | python | def attach_tracker(self, stanza, tracker=None):
if stanza.xep0184_received is not None:
raise ValueError(
"requesting delivery receipts for delivery receipts is not "
"allowed"
)
if stanza.type_ == aioxmpp.MessageType.ERROR:
raise ValueError(
"requesting delivery receipts for errors is not supported"
)
if tracker is None:
tracker = aioxmpp.tracking.MessageTracker()
stanza.xep0184_request_receipt = True
stanza.autoset_id()
self._bare_jid_maps[stanza.to, stanza.id_] = tracker
return tracker | [
"def",
"attach_tracker",
"(",
"self",
",",
"stanza",
",",
"tracker",
"=",
"None",
")",
":",
"if",
"stanza",
".",
"xep0184_received",
"is",
"not",
"None",
":",
"raise",
"ValueError",
"(",
"\"requesting delivery receipts for delivery receipts is not \"",
"\"allowed\"",
")",
"if",
"stanza",
".",
"type_",
"==",
"aioxmpp",
".",
"MessageType",
".",
"ERROR",
":",
"raise",
"ValueError",
"(",
"\"requesting delivery receipts for errors is not supported\"",
")",
"if",
"tracker",
"is",
"None",
":",
"tracker",
"=",
"aioxmpp",
".",
"tracking",
".",
"MessageTracker",
"(",
")",
"stanza",
".",
"xep0184_request_receipt",
"=",
"True",
"stanza",
".",
"autoset_id",
"(",
")",
"self",
".",
"_bare_jid_maps",
"[",
"stanza",
".",
"to",
",",
"stanza",
".",
"id_",
"]",
"=",
"tracker",
"return",
"tracker"
] | Return a new tracker or modify one to track the stanza.
:param stanza: Stanza to track.
:type stanza: :class:`aioxmpp.Message`
:param tracker: Existing tracker to attach to.
:type tracker: :class:`.tracking.MessageTracker`
:raises ValueError: if the stanza is of type
:attr:`~aioxmpp.MessageType.ERROR`
:raises ValueError: if the stanza contains a delivery receipt
:return: The message tracker for the stanza.
:rtype: :class:`.tracking.MessageTracker`
The `stanza` gets a :xep:`184` reciept request attached and internal
handlers are set up to update the `tracker` state once a confirmation
is received.
.. warning::
See the :ref:`api-tracking-memory`. | [
"Return",
"a",
"new",
"tracker",
"or",
"modify",
"one",
"to",
"track",
"the",
"stanza",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/mdr/service.py#L73-L112 |
727 | horazont/aioxmpp | aioxmpp/private_xml/service.py | PrivateXMLService.get_private_xml | def get_private_xml(self, query_xso):
"""
Get the private XML data for the element `query_xso` from the
server.
:param query_xso: the object to retrieve.
:returns: the stored private XML data.
`query_xso` *must* serialize to an empty XML node of the
wanted namespace and type and *must* be registered as private
XML :class:`~private_xml_xso.Query` payload.
"""
iq = aioxmpp.IQ(
type_=aioxmpp.IQType.GET,
payload=private_xml_xso.Query(query_xso)
)
return (yield from self.client.send(iq)) | python | def get_private_xml(self, query_xso):
iq = aioxmpp.IQ(
type_=aioxmpp.IQType.GET,
payload=private_xml_xso.Query(query_xso)
)
return (yield from self.client.send(iq)) | [
"def",
"get_private_xml",
"(",
"self",
",",
"query_xso",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"GET",
",",
"payload",
"=",
"private_xml_xso",
".",
"Query",
"(",
"query_xso",
")",
")",
"return",
"(",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
")"
] | Get the private XML data for the element `query_xso` from the
server.
:param query_xso: the object to retrieve.
:returns: the stored private XML data.
`query_xso` *must* serialize to an empty XML node of the
wanted namespace and type and *must* be registered as private
XML :class:`~private_xml_xso.Query` payload. | [
"Get",
"the",
"private",
"XML",
"data",
"for",
"the",
"element",
"query_xso",
"from",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/private_xml/service.py#L43-L60 |
728 | horazont/aioxmpp | aioxmpp/private_xml/service.py | PrivateXMLService.set_private_xml | def set_private_xml(self, xso):
"""
Store the serialization of `xso` on the server as the private XML
data for the namespace of `xso`.
:param xso: the XSO whose serialization is send as private XML data.
"""
iq = aioxmpp.IQ(
type_=aioxmpp.IQType.SET,
payload=private_xml_xso.Query(xso)
)
yield from self.client.send(iq) | python | def set_private_xml(self, xso):
iq = aioxmpp.IQ(
type_=aioxmpp.IQType.SET,
payload=private_xml_xso.Query(xso)
)
yield from self.client.send(iq) | [
"def",
"set_private_xml",
"(",
"self",
",",
"xso",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"private_xml_xso",
".",
"Query",
"(",
"xso",
")",
")",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")"
] | Store the serialization of `xso` on the server as the private XML
data for the namespace of `xso`.
:param xso: the XSO whose serialization is send as private XML data. | [
"Store",
"the",
"serialization",
"of",
"xso",
"on",
"the",
"server",
"as",
"the",
"private",
"XML",
"data",
"for",
"the",
"namespace",
"of",
"xso",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/private_xml/service.py#L63-L74 |
729 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient._get_bookmarks | def _get_bookmarks(self):
"""
Get the stored bookmarks from the server.
:returns: a list of bookmarks
"""
res = yield from self._private_xml.get_private_xml(
bookmark_xso.Storage()
)
return res.registered_payload.bookmarks | python | def _get_bookmarks(self):
res = yield from self._private_xml.get_private_xml(
bookmark_xso.Storage()
)
return res.registered_payload.bookmarks | [
"def",
"_get_bookmarks",
"(",
"self",
")",
":",
"res",
"=",
"yield",
"from",
"self",
".",
"_private_xml",
".",
"get_private_xml",
"(",
"bookmark_xso",
".",
"Storage",
"(",
")",
")",
"return",
"res",
".",
"registered_payload",
".",
"bookmarks"
] | Get the stored bookmarks from the server.
:returns: a list of bookmarks | [
"Get",
"the",
"stored",
"bookmarks",
"from",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L120-L130 |
730 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient._set_bookmarks | def _set_bookmarks(self, bookmarks):
"""
Set the bookmarks stored on the server.
"""
storage = bookmark_xso.Storage()
storage.bookmarks[:] = bookmarks
yield from self._private_xml.set_private_xml(storage) | python | def _set_bookmarks(self, bookmarks):
storage = bookmark_xso.Storage()
storage.bookmarks[:] = bookmarks
yield from self._private_xml.set_private_xml(storage) | [
"def",
"_set_bookmarks",
"(",
"self",
",",
"bookmarks",
")",
":",
"storage",
"=",
"bookmark_xso",
".",
"Storage",
"(",
")",
"storage",
".",
"bookmarks",
"[",
":",
"]",
"=",
"bookmarks",
"yield",
"from",
"self",
".",
"_private_xml",
".",
"set_private_xml",
"(",
"storage",
")"
] | Set the bookmarks stored on the server. | [
"Set",
"the",
"bookmarks",
"stored",
"on",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L133-L139 |
731 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient.get_bookmarks | def get_bookmarks(self):
"""
Get the stored bookmarks from the server. Causes signals to be
fired to reflect the changes.
:returns: a list of bookmarks
"""
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
self._diff_emit_update(bookmarks)
return bookmarks | python | def get_bookmarks(self):
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
self._diff_emit_update(bookmarks)
return bookmarks | [
"def",
"get_bookmarks",
"(",
"self",
")",
":",
"with",
"(",
"yield",
"from",
"self",
".",
"_lock",
")",
":",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"self",
".",
"_diff_emit_update",
"(",
"bookmarks",
")",
"return",
"bookmarks"
] | Get the stored bookmarks from the server. Causes signals to be
fired to reflect the changes.
:returns: a list of bookmarks | [
"Get",
"the",
"stored",
"bookmarks",
"from",
"the",
"server",
".",
"Causes",
"signals",
"to",
"be",
"fired",
"to",
"reflect",
"the",
"changes",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L268-L278 |
732 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient.set_bookmarks | def set_bookmarks(self, bookmarks):
"""
Store the sequence of bookmarks `bookmarks`.
Causes signals to be fired to reflect the changes.
.. note:: This should normally not be used. It does not
mitigate the race condition between clients
concurrently modifying the bookmarks and may lead to
data loss. Use :meth:`add_bookmark`,
:meth:`discard_bookmark` and :meth:`update_bookmark`
instead. This method still has use-cases (modifying
the bookmarklist at large, e.g. by syncing the
remote store with local data).
"""
with (yield from self._lock):
yield from self._set_bookmarks(bookmarks)
self._diff_emit_update(bookmarks) | python | def set_bookmarks(self, bookmarks):
with (yield from self._lock):
yield from self._set_bookmarks(bookmarks)
self._diff_emit_update(bookmarks) | [
"def",
"set_bookmarks",
"(",
"self",
",",
"bookmarks",
")",
":",
"with",
"(",
"yield",
"from",
"self",
".",
"_lock",
")",
":",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"bookmarks",
")",
"self",
".",
"_diff_emit_update",
"(",
"bookmarks",
")"
] | Store the sequence of bookmarks `bookmarks`.
Causes signals to be fired to reflect the changes.
.. note:: This should normally not be used. It does not
mitigate the race condition between clients
concurrently modifying the bookmarks and may lead to
data loss. Use :meth:`add_bookmark`,
:meth:`discard_bookmark` and :meth:`update_bookmark`
instead. This method still has use-cases (modifying
the bookmarklist at large, e.g. by syncing the
remote store with local data). | [
"Store",
"the",
"sequence",
"of",
"bookmarks",
"bookmarks",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L281-L298 |
733 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient.add_bookmark | def add_bookmark(self, new_bookmark, *, max_retries=3):
"""
Add a bookmark and check whether it was successfully added to the
bookmark list. Already existant bookmarks are not added twice.
:param new_bookmark: the bookmark to add
:type new_bookmark: an instance of :class:`~bookmark_xso.Bookmark`
:param max_retries: the number of retries if setting the bookmark
fails
:type max_retries: :class:`int`
:raises RuntimeError: if the bookmark is not in the bookmark list
after `max_retries` retries.
After setting the bookmark it is checked, whether the bookmark
is in the online storage, if it is not it is tried again at most
`max_retries` times to add the bookmark. A :class:`RuntimeError`
is raised if the bookmark could not be added successfully after
`max_retries`.
"""
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
try:
modified_bookmarks = list(bookmarks)
if new_bookmark not in bookmarks:
modified_bookmarks.append(new_bookmark)
yield from self._set_bookmarks(modified_bookmarks)
retries = 0
bookmarks = yield from self._get_bookmarks()
while retries < max_retries:
if new_bookmark in bookmarks:
break
modified_bookmarks = list(bookmarks)
modified_bookmarks.append(new_bookmark)
yield from self._set_bookmarks(modified_bookmarks)
bookmarks = yield from self._get_bookmarks()
retries += 1
if new_bookmark not in bookmarks:
raise RuntimeError("Could not add bookmark")
finally:
self._diff_emit_update(bookmarks) | python | def add_bookmark(self, new_bookmark, *, max_retries=3):
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
try:
modified_bookmarks = list(bookmarks)
if new_bookmark not in bookmarks:
modified_bookmarks.append(new_bookmark)
yield from self._set_bookmarks(modified_bookmarks)
retries = 0
bookmarks = yield from self._get_bookmarks()
while retries < max_retries:
if new_bookmark in bookmarks:
break
modified_bookmarks = list(bookmarks)
modified_bookmarks.append(new_bookmark)
yield from self._set_bookmarks(modified_bookmarks)
bookmarks = yield from self._get_bookmarks()
retries += 1
if new_bookmark not in bookmarks:
raise RuntimeError("Could not add bookmark")
finally:
self._diff_emit_update(bookmarks) | [
"def",
"add_bookmark",
"(",
"self",
",",
"new_bookmark",
",",
"*",
",",
"max_retries",
"=",
"3",
")",
":",
"with",
"(",
"yield",
"from",
"self",
".",
"_lock",
")",
":",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"try",
":",
"modified_bookmarks",
"=",
"list",
"(",
"bookmarks",
")",
"if",
"new_bookmark",
"not",
"in",
"bookmarks",
":",
"modified_bookmarks",
".",
"append",
"(",
"new_bookmark",
")",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"modified_bookmarks",
")",
"retries",
"=",
"0",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"while",
"retries",
"<",
"max_retries",
":",
"if",
"new_bookmark",
"in",
"bookmarks",
":",
"break",
"modified_bookmarks",
"=",
"list",
"(",
"bookmarks",
")",
"modified_bookmarks",
".",
"append",
"(",
"new_bookmark",
")",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"modified_bookmarks",
")",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"retries",
"+=",
"1",
"if",
"new_bookmark",
"not",
"in",
"bookmarks",
":",
"raise",
"RuntimeError",
"(",
"\"Could not add bookmark\"",
")",
"finally",
":",
"self",
".",
"_diff_emit_update",
"(",
"bookmarks",
")"
] | Add a bookmark and check whether it was successfully added to the
bookmark list. Already existant bookmarks are not added twice.
:param new_bookmark: the bookmark to add
:type new_bookmark: an instance of :class:`~bookmark_xso.Bookmark`
:param max_retries: the number of retries if setting the bookmark
fails
:type max_retries: :class:`int`
:raises RuntimeError: if the bookmark is not in the bookmark list
after `max_retries` retries.
After setting the bookmark it is checked, whether the bookmark
is in the online storage, if it is not it is tried again at most
`max_retries` times to add the bookmark. A :class:`RuntimeError`
is raised if the bookmark could not be added successfully after
`max_retries`. | [
"Add",
"a",
"bookmark",
"and",
"check",
"whether",
"it",
"was",
"successfully",
"added",
"to",
"the",
"bookmark",
"list",
".",
"Already",
"existant",
"bookmarks",
"are",
"not",
"added",
"twice",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L312-L356 |
734 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient.discard_bookmark | def discard_bookmark(self, bookmark_to_remove, *, max_retries=3):
"""
Remove a bookmark and check it has been removed.
:param bookmark_to_remove: the bookmark to remove
:type bookmark_to_remove: a :class:`~bookmark_xso.Bookmark` subclass.
:param max_retries: the number of retries of removing the bookmark
fails.
:type max_retries: :class:`int`
:raises RuntimeError: if the bookmark is not removed from
bookmark list after `max_retries`
retries.
If there are multiple occurences of the same bookmark exactly
one is removed.
This does nothing if the bookmarks does not match an existing
bookmark according to bookmark-equality.
After setting the bookmark it is checked, whether the bookmark
is removed in the online storage, if it is not it is tried
again at most `max_retries` times to remove the bookmark. A
:class:`RuntimeError` is raised if the bookmark could not be
removed successfully after `max_retries`.
"""
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
occurences = bookmarks.count(bookmark_to_remove)
try:
if not occurences:
return
modified_bookmarks = list(bookmarks)
modified_bookmarks.remove(bookmark_to_remove)
yield from self._set_bookmarks(modified_bookmarks)
retries = 0
bookmarks = yield from self._get_bookmarks()
new_occurences = bookmarks.count(bookmark_to_remove)
while retries < max_retries:
if new_occurences < occurences:
break
modified_bookmarks = list(bookmarks)
modified_bookmarks.remove(bookmark_to_remove)
yield from self._set_bookmarks(modified_bookmarks)
bookmarks = yield from self._get_bookmarks()
new_occurences = bookmarks.count(bookmark_to_remove)
retries += 1
if new_occurences >= occurences:
raise RuntimeError("Could not remove bookmark")
finally:
self._diff_emit_update(bookmarks) | python | def discard_bookmark(self, bookmark_to_remove, *, max_retries=3):
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
occurences = bookmarks.count(bookmark_to_remove)
try:
if not occurences:
return
modified_bookmarks = list(bookmarks)
modified_bookmarks.remove(bookmark_to_remove)
yield from self._set_bookmarks(modified_bookmarks)
retries = 0
bookmarks = yield from self._get_bookmarks()
new_occurences = bookmarks.count(bookmark_to_remove)
while retries < max_retries:
if new_occurences < occurences:
break
modified_bookmarks = list(bookmarks)
modified_bookmarks.remove(bookmark_to_remove)
yield from self._set_bookmarks(modified_bookmarks)
bookmarks = yield from self._get_bookmarks()
new_occurences = bookmarks.count(bookmark_to_remove)
retries += 1
if new_occurences >= occurences:
raise RuntimeError("Could not remove bookmark")
finally:
self._diff_emit_update(bookmarks) | [
"def",
"discard_bookmark",
"(",
"self",
",",
"bookmark_to_remove",
",",
"*",
",",
"max_retries",
"=",
"3",
")",
":",
"with",
"(",
"yield",
"from",
"self",
".",
"_lock",
")",
":",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"occurences",
"=",
"bookmarks",
".",
"count",
"(",
"bookmark_to_remove",
")",
"try",
":",
"if",
"not",
"occurences",
":",
"return",
"modified_bookmarks",
"=",
"list",
"(",
"bookmarks",
")",
"modified_bookmarks",
".",
"remove",
"(",
"bookmark_to_remove",
")",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"modified_bookmarks",
")",
"retries",
"=",
"0",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"new_occurences",
"=",
"bookmarks",
".",
"count",
"(",
"bookmark_to_remove",
")",
"while",
"retries",
"<",
"max_retries",
":",
"if",
"new_occurences",
"<",
"occurences",
":",
"break",
"modified_bookmarks",
"=",
"list",
"(",
"bookmarks",
")",
"modified_bookmarks",
".",
"remove",
"(",
"bookmark_to_remove",
")",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"modified_bookmarks",
")",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"new_occurences",
"=",
"bookmarks",
".",
"count",
"(",
"bookmark_to_remove",
")",
"retries",
"+=",
"1",
"if",
"new_occurences",
">=",
"occurences",
":",
"raise",
"RuntimeError",
"(",
"\"Could not remove bookmark\"",
")",
"finally",
":",
"self",
".",
"_diff_emit_update",
"(",
"bookmarks",
")"
] | Remove a bookmark and check it has been removed.
:param bookmark_to_remove: the bookmark to remove
:type bookmark_to_remove: a :class:`~bookmark_xso.Bookmark` subclass.
:param max_retries: the number of retries of removing the bookmark
fails.
:type max_retries: :class:`int`
:raises RuntimeError: if the bookmark is not removed from
bookmark list after `max_retries`
retries.
If there are multiple occurences of the same bookmark exactly
one is removed.
This does nothing if the bookmarks does not match an existing
bookmark according to bookmark-equality.
After setting the bookmark it is checked, whether the bookmark
is removed in the online storage, if it is not it is tried
again at most `max_retries` times to remove the bookmark. A
:class:`RuntimeError` is raised if the bookmark could not be
removed successfully after `max_retries`. | [
"Remove",
"a",
"bookmark",
"and",
"check",
"it",
"has",
"been",
"removed",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L359-L413 |
735 | horazont/aioxmpp | aioxmpp/bookmarks/service.py | BookmarkClient.update_bookmark | def update_bookmark(self, old, new, *, max_retries=3):
"""
Update a bookmark and check it was successful.
The bookmark matches an existing bookmark `old` according to
bookmark equalitiy and replaces it by `new`. The bookmark
`new` is added if no bookmark matching `old` exists.
:param old: the bookmark to replace
:type bookmark_to_remove: a :class:`~bookmark_xso.Bookmark` subclass.
:param new: the replacement bookmark
:type bookmark_to_remove: a :class:`~bookmark_xso.Bookmark` subclass.
:param max_retries: the number of retries of removing the bookmark
fails.
:type max_retries: :class:`int`
:raises RuntimeError: if the bookmark is not in the bookmark list
after `max_retries` retries.
After replacing the bookmark it is checked, whether the
bookmark `new` is in the online storage, if it is not it is
tried again at most `max_retries` times to replace the
bookmark. A :class:`RuntimeError` is raised if the bookmark
could not be replaced successfully after `max_retries`.
.. note:: Do not modify a bookmark retrieved from the signals
or from :meth:`get_bookmarks` to obtain the bookmark
`new`, this will lead to data corruption as they are
passed by reference. Instead use :func:`copy.copy`
and modify the copy.
"""
def replace_bookmark(bookmarks, old, new):
modified_bookmarks = list(bookmarks)
try:
i = bookmarks.index(old)
modified_bookmarks[i] = new
except ValueError:
modified_bookmarks.append(new)
return modified_bookmarks
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
try:
yield from self._set_bookmarks(
replace_bookmark(bookmarks, old, new)
)
retries = 0
bookmarks = yield from self._get_bookmarks()
while retries < max_retries:
if new in bookmarks:
break
yield from self._set_bookmarks(
replace_bookmark(bookmarks, old, new)
)
bookmarks = yield from self._get_bookmarks()
retries += 1
if new not in bookmarks:
raise RuntimeError("Cold not update bookmark")
finally:
self._diff_emit_update(bookmarks) | python | def update_bookmark(self, old, new, *, max_retries=3):
def replace_bookmark(bookmarks, old, new):
modified_bookmarks = list(bookmarks)
try:
i = bookmarks.index(old)
modified_bookmarks[i] = new
except ValueError:
modified_bookmarks.append(new)
return modified_bookmarks
with (yield from self._lock):
bookmarks = yield from self._get_bookmarks()
try:
yield from self._set_bookmarks(
replace_bookmark(bookmarks, old, new)
)
retries = 0
bookmarks = yield from self._get_bookmarks()
while retries < max_retries:
if new in bookmarks:
break
yield from self._set_bookmarks(
replace_bookmark(bookmarks, old, new)
)
bookmarks = yield from self._get_bookmarks()
retries += 1
if new not in bookmarks:
raise RuntimeError("Cold not update bookmark")
finally:
self._diff_emit_update(bookmarks) | [
"def",
"update_bookmark",
"(",
"self",
",",
"old",
",",
"new",
",",
"*",
",",
"max_retries",
"=",
"3",
")",
":",
"def",
"replace_bookmark",
"(",
"bookmarks",
",",
"old",
",",
"new",
")",
":",
"modified_bookmarks",
"=",
"list",
"(",
"bookmarks",
")",
"try",
":",
"i",
"=",
"bookmarks",
".",
"index",
"(",
"old",
")",
"modified_bookmarks",
"[",
"i",
"]",
"=",
"new",
"except",
"ValueError",
":",
"modified_bookmarks",
".",
"append",
"(",
"new",
")",
"return",
"modified_bookmarks",
"with",
"(",
"yield",
"from",
"self",
".",
"_lock",
")",
":",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"try",
":",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"replace_bookmark",
"(",
"bookmarks",
",",
"old",
",",
"new",
")",
")",
"retries",
"=",
"0",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"while",
"retries",
"<",
"max_retries",
":",
"if",
"new",
"in",
"bookmarks",
":",
"break",
"yield",
"from",
"self",
".",
"_set_bookmarks",
"(",
"replace_bookmark",
"(",
"bookmarks",
",",
"old",
",",
"new",
")",
")",
"bookmarks",
"=",
"yield",
"from",
"self",
".",
"_get_bookmarks",
"(",
")",
"retries",
"+=",
"1",
"if",
"new",
"not",
"in",
"bookmarks",
":",
"raise",
"RuntimeError",
"(",
"\"Cold not update bookmark\"",
")",
"finally",
":",
"self",
".",
"_diff_emit_update",
"(",
"bookmarks",
")"
] | Update a bookmark and check it was successful.
The bookmark matches an existing bookmark `old` according to
bookmark equalitiy and replaces it by `new`. The bookmark
`new` is added if no bookmark matching `old` exists.
:param old: the bookmark to replace
:type bookmark_to_remove: a :class:`~bookmark_xso.Bookmark` subclass.
:param new: the replacement bookmark
:type bookmark_to_remove: a :class:`~bookmark_xso.Bookmark` subclass.
:param max_retries: the number of retries of removing the bookmark
fails.
:type max_retries: :class:`int`
:raises RuntimeError: if the bookmark is not in the bookmark list
after `max_retries` retries.
After replacing the bookmark it is checked, whether the
bookmark `new` is in the online storage, if it is not it is
tried again at most `max_retries` times to replace the
bookmark. A :class:`RuntimeError` is raised if the bookmark
could not be replaced successfully after `max_retries`.
.. note:: Do not modify a bookmark retrieved from the signals
or from :meth:`get_bookmarks` to obtain the bookmark
`new`, this will lead to data corruption as they are
passed by reference. Instead use :func:`copy.copy`
and modify the copy. | [
"Update",
"a",
"bookmark",
"and",
"check",
"it",
"was",
"successful",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/bookmarks/service.py#L416-L479 |
736 | horazont/aioxmpp | aioxmpp/disco/service.py | Node.iter_identities | def iter_identities(self, stanza=None):
"""
Return an iterator of tuples describing the identities of the node.
:param stanza: The IQ request stanza
:type stanza: :class:`~aioxmpp.IQ` or :data:`None`
:rtype: iterable of (:class:`str`, :class:`str`, :class:`str` or
:data:`None`, :class:`str` or :data:`None`) tuples
:return: :xep:`30` identities of this node
`stanza` can be the :class:`aioxmpp.IQ` stanza of the request. This can
be used to hide a node depending on who is asking. If the returned
iterable is empty, the :class:`~.DiscoServer` returns an
``<item-not-found/>`` error.
`stanza` may be :data:`None` if the identities are queried without
a specific request context. In that case, implementors should assume
that the result is visible to everybody.
.. note::
Subclasses must allow :data:`None` for `stanza` and default it to
:data:`None`.
Return an iterator which yields tuples consisting of the category, the
type, the language code and the name of each identity declared in this
:class:`Node`.
Both the language code and the name may be :data:`None`, if no names or
a name without language code have been declared.
"""
for (category, type_), names in self._identities.items():
for lang, name in names.items():
yield category, type_, lang, name
if not names:
yield category, type_, None, None | python | def iter_identities(self, stanza=None):
for (category, type_), names in self._identities.items():
for lang, name in names.items():
yield category, type_, lang, name
if not names:
yield category, type_, None, None | [
"def",
"iter_identities",
"(",
"self",
",",
"stanza",
"=",
"None",
")",
":",
"for",
"(",
"category",
",",
"type_",
")",
",",
"names",
"in",
"self",
".",
"_identities",
".",
"items",
"(",
")",
":",
"for",
"lang",
",",
"name",
"in",
"names",
".",
"items",
"(",
")",
":",
"yield",
"category",
",",
"type_",
",",
"lang",
",",
"name",
"if",
"not",
"names",
":",
"yield",
"category",
",",
"type_",
",",
"None",
",",
"None"
] | Return an iterator of tuples describing the identities of the node.
:param stanza: The IQ request stanza
:type stanza: :class:`~aioxmpp.IQ` or :data:`None`
:rtype: iterable of (:class:`str`, :class:`str`, :class:`str` or
:data:`None`, :class:`str` or :data:`None`) tuples
:return: :xep:`30` identities of this node
`stanza` can be the :class:`aioxmpp.IQ` stanza of the request. This can
be used to hide a node depending on who is asking. If the returned
iterable is empty, the :class:`~.DiscoServer` returns an
``<item-not-found/>`` error.
`stanza` may be :data:`None` if the identities are queried without
a specific request context. In that case, implementors should assume
that the result is visible to everybody.
.. note::
Subclasses must allow :data:`None` for `stanza` and default it to
:data:`None`.
Return an iterator which yields tuples consisting of the category, the
type, the language code and the name of each identity declared in this
:class:`Node`.
Both the language code and the name may be :data:`None`, if no names or
a name without language code have been declared. | [
"Return",
"an",
"iterator",
"of",
"tuples",
"describing",
"the",
"identities",
"of",
"the",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/disco/service.py#L98-L133 |
737 | horazont/aioxmpp | aioxmpp/disco/service.py | Node.iter_features | def iter_features(self, stanza=None):
"""
Return an iterator which yields the features of the node.
:param stanza: The IQ request stanza
:type stanza: :class:`~aioxmpp.IQ`
:rtype: iterable of :class:`str`
:return: :xep:`30` features of this node
`stanza` is the :class:`aioxmpp.IQ` stanza of the request. This can be
used to filter the list according to who is asking (not recommended).
`stanza` may be :data:`None` if the features are queried without
a specific request context. In that case, implementors should assume
that the result is visible to everybody.
.. note::
Subclasses must allow :data:`None` for `stanza` and default it to
:data:`None`.
The features are returned as strings. The features demanded by
:xep:`30` are always returned.
"""
return itertools.chain(
iter(self.STATIC_FEATURES),
iter(self._features)
) | python | def iter_features(self, stanza=None):
return itertools.chain(
iter(self.STATIC_FEATURES),
iter(self._features)
) | [
"def",
"iter_features",
"(",
"self",
",",
"stanza",
"=",
"None",
")",
":",
"return",
"itertools",
".",
"chain",
"(",
"iter",
"(",
"self",
".",
"STATIC_FEATURES",
")",
",",
"iter",
"(",
"self",
".",
"_features",
")",
")"
] | Return an iterator which yields the features of the node.
:param stanza: The IQ request stanza
:type stanza: :class:`~aioxmpp.IQ`
:rtype: iterable of :class:`str`
:return: :xep:`30` features of this node
`stanza` is the :class:`aioxmpp.IQ` stanza of the request. This can be
used to filter the list according to who is asking (not recommended).
`stanza` may be :data:`None` if the features are queried without
a specific request context. In that case, implementors should assume
that the result is visible to everybody.
.. note::
Subclasses must allow :data:`None` for `stanza` and default it to
:data:`None`.
The features are returned as strings. The features demanded by
:xep:`30` are always returned. | [
"Return",
"an",
"iterator",
"which",
"yields",
"the",
"features",
"of",
"the",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/disco/service.py#L135-L163 |
738 | horazont/aioxmpp | aioxmpp/disco/service.py | Node.register_feature | def register_feature(self, var):
"""
Register a feature with the namespace variable `var`.
If the feature is already registered or part of the default :xep:`30`
features, a :class:`ValueError` is raised.
"""
if var in self._features or var in self.STATIC_FEATURES:
raise ValueError("feature already claimed: {!r}".format(var))
self._features.add(var)
self.on_info_changed() | python | def register_feature(self, var):
if var in self._features or var in self.STATIC_FEATURES:
raise ValueError("feature already claimed: {!r}".format(var))
self._features.add(var)
self.on_info_changed() | [
"def",
"register_feature",
"(",
"self",
",",
"var",
")",
":",
"if",
"var",
"in",
"self",
".",
"_features",
"or",
"var",
"in",
"self",
".",
"STATIC_FEATURES",
":",
"raise",
"ValueError",
"(",
"\"feature already claimed: {!r}\"",
".",
"format",
"(",
"var",
")",
")",
"self",
".",
"_features",
".",
"add",
"(",
"var",
")",
"self",
".",
"on_info_changed",
"(",
")"
] | Register a feature with the namespace variable `var`.
If the feature is already registered or part of the default :xep:`30`
features, a :class:`ValueError` is raised. | [
"Register",
"a",
"feature",
"with",
"the",
"namespace",
"variable",
"var",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/disco/service.py#L192-L202 |
739 | horazont/aioxmpp | aioxmpp/disco/service.py | Node.register_identity | def register_identity(self, category, type_, *, names={}):
"""
Register an identity with the given `category` and `type_`.
If there is already a registered identity with the same `category` and
`type_`, :class:`ValueError` is raised.
`names` may be a mapping which maps :class:`.structs.LanguageTag`
instances to strings. This mapping will be used to produce
``<identity/>`` declarations with the respective ``xml:lang`` and
``name`` attributes.
"""
key = category, type_
if key in self._identities:
raise ValueError("identity already claimed: {!r}".format(key))
self._identities[key] = names
self.on_info_changed() | python | def register_identity(self, category, type_, *, names={}):
key = category, type_
if key in self._identities:
raise ValueError("identity already claimed: {!r}".format(key))
self._identities[key] = names
self.on_info_changed() | [
"def",
"register_identity",
"(",
"self",
",",
"category",
",",
"type_",
",",
"*",
",",
"names",
"=",
"{",
"}",
")",
":",
"key",
"=",
"category",
",",
"type_",
"if",
"key",
"in",
"self",
".",
"_identities",
":",
"raise",
"ValueError",
"(",
"\"identity already claimed: {!r}\"",
".",
"format",
"(",
"key",
")",
")",
"self",
".",
"_identities",
"[",
"key",
"]",
"=",
"names",
"self",
".",
"on_info_changed",
"(",
")"
] | Register an identity with the given `category` and `type_`.
If there is already a registered identity with the same `category` and
`type_`, :class:`ValueError` is raised.
`names` may be a mapping which maps :class:`.structs.LanguageTag`
instances to strings. This mapping will be used to produce
``<identity/>`` declarations with the respective ``xml:lang`` and
``name`` attributes. | [
"Register",
"an",
"identity",
"with",
"the",
"given",
"category",
"and",
"type_",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/disco/service.py#L204-L220 |
740 | horazont/aioxmpp | aioxmpp/disco/service.py | DiscoClient.query_info | def query_info(self, jid, *,
node=None, require_fresh=False, timeout=None,
no_cache=False):
"""
Query the features and identities of the specified entity.
:param jid: The entity to query.
:type jid: :class:`aioxmpp.JID`
:param node: The node to query.
:type node: :class:`str` or :data:`None`
:param require_fresh: Boolean flag to discard previous caches.
:type require_fresh: :class:`bool`
:param timeout: Optional timeout for the response.
:type timeout: :class:`float`
:param no_cache: Boolean flag to forbid caching of the request.
:type no_cache: :class:`bool`
:rtype: :class:`.xso.InfoQuery`
:return: Service discovery information of the `node` at `jid`.
The requests are cached. This means that only one request is ever fired
for a given target (identified by the `jid` and the `node`). The
request is re-used for all subsequent requests to that identity.
If `require_fresh` is set to true, the above does not hold and a fresh
request is always created. The new request is the request which will be
used as alias for subsequent requests to the same identity.
The visible effects of this are twofold:
* Caching: Results of requests are implicitly cached
* Aliasing: Two concurrent requests will be aliased to one request to
save computing resources
Both can be turned off by using `require_fresh`. In general, you should
not need to use `require_fresh`, as all requests are implicitly
cancelled whenever the underlying session gets destroyed.
`no_cache` can be set to true to prevent future requests to be aliased
to this request, i.e. the request is not stored in the internal request
cache. This does not affect `require_fresh`, i.e. if a cached result is
available, it is used.
The `timeout` can be used to restrict the time to wait for a
response. If the timeout triggers, :class:`TimeoutError` is raised.
If :meth:`~.Client.send` raises an
exception, all queries which were running simultanously for the same
target re-raise that exception. The result is not cached though. If a
new query is sent at a later point for the same target, a new query is
actually sent, independent of the value chosen for `require_fresh`.
.. versionchanged:: 0.9
The `no_cache` argument was added.
"""
key = jid, node
if not require_fresh:
try:
request = self._info_pending[key]
except KeyError:
pass
else:
try:
return (yield from request)
except asyncio.CancelledError:
pass
request = asyncio.ensure_future(
self.send_and_decode_info_query(jid, node)
)
request.add_done_callback(
functools.partial(
self._handle_info_received,
jid,
node
)
)
if not no_cache:
self._info_pending[key] = request
try:
if timeout is not None:
try:
result = yield from asyncio.wait_for(
request,
timeout=timeout)
except asyncio.TimeoutError:
raise TimeoutError()
else:
result = yield from request
except: # NOQA
if request.done():
try:
pending = self._info_pending[key]
except KeyError:
pass
else:
if pending is request:
del self._info_pending[key]
raise
return result | python | def query_info(self, jid, *,
node=None, require_fresh=False, timeout=None,
no_cache=False):
key = jid, node
if not require_fresh:
try:
request = self._info_pending[key]
except KeyError:
pass
else:
try:
return (yield from request)
except asyncio.CancelledError:
pass
request = asyncio.ensure_future(
self.send_and_decode_info_query(jid, node)
)
request.add_done_callback(
functools.partial(
self._handle_info_received,
jid,
node
)
)
if not no_cache:
self._info_pending[key] = request
try:
if timeout is not None:
try:
result = yield from asyncio.wait_for(
request,
timeout=timeout)
except asyncio.TimeoutError:
raise TimeoutError()
else:
result = yield from request
except: # NOQA
if request.done():
try:
pending = self._info_pending[key]
except KeyError:
pass
else:
if pending is request:
del self._info_pending[key]
raise
return result | [
"def",
"query_info",
"(",
"self",
",",
"jid",
",",
"*",
",",
"node",
"=",
"None",
",",
"require_fresh",
"=",
"False",
",",
"timeout",
"=",
"None",
",",
"no_cache",
"=",
"False",
")",
":",
"key",
"=",
"jid",
",",
"node",
"if",
"not",
"require_fresh",
":",
"try",
":",
"request",
"=",
"self",
".",
"_info_pending",
"[",
"key",
"]",
"except",
"KeyError",
":",
"pass",
"else",
":",
"try",
":",
"return",
"(",
"yield",
"from",
"request",
")",
"except",
"asyncio",
".",
"CancelledError",
":",
"pass",
"request",
"=",
"asyncio",
".",
"ensure_future",
"(",
"self",
".",
"send_and_decode_info_query",
"(",
"jid",
",",
"node",
")",
")",
"request",
".",
"add_done_callback",
"(",
"functools",
".",
"partial",
"(",
"self",
".",
"_handle_info_received",
",",
"jid",
",",
"node",
")",
")",
"if",
"not",
"no_cache",
":",
"self",
".",
"_info_pending",
"[",
"key",
"]",
"=",
"request",
"try",
":",
"if",
"timeout",
"is",
"not",
"None",
":",
"try",
":",
"result",
"=",
"yield",
"from",
"asyncio",
".",
"wait_for",
"(",
"request",
",",
"timeout",
"=",
"timeout",
")",
"except",
"asyncio",
".",
"TimeoutError",
":",
"raise",
"TimeoutError",
"(",
")",
"else",
":",
"result",
"=",
"yield",
"from",
"request",
"except",
":",
"# NOQA",
"if",
"request",
".",
"done",
"(",
")",
":",
"try",
":",
"pending",
"=",
"self",
".",
"_info_pending",
"[",
"key",
"]",
"except",
"KeyError",
":",
"pass",
"else",
":",
"if",
"pending",
"is",
"request",
":",
"del",
"self",
".",
"_info_pending",
"[",
"key",
"]",
"raise",
"return",
"result"
] | Query the features and identities of the specified entity.
:param jid: The entity to query.
:type jid: :class:`aioxmpp.JID`
:param node: The node to query.
:type node: :class:`str` or :data:`None`
:param require_fresh: Boolean flag to discard previous caches.
:type require_fresh: :class:`bool`
:param timeout: Optional timeout for the response.
:type timeout: :class:`float`
:param no_cache: Boolean flag to forbid caching of the request.
:type no_cache: :class:`bool`
:rtype: :class:`.xso.InfoQuery`
:return: Service discovery information of the `node` at `jid`.
The requests are cached. This means that only one request is ever fired
for a given target (identified by the `jid` and the `node`). The
request is re-used for all subsequent requests to that identity.
If `require_fresh` is set to true, the above does not hold and a fresh
request is always created. The new request is the request which will be
used as alias for subsequent requests to the same identity.
The visible effects of this are twofold:
* Caching: Results of requests are implicitly cached
* Aliasing: Two concurrent requests will be aliased to one request to
save computing resources
Both can be turned off by using `require_fresh`. In general, you should
not need to use `require_fresh`, as all requests are implicitly
cancelled whenever the underlying session gets destroyed.
`no_cache` can be set to true to prevent future requests to be aliased
to this request, i.e. the request is not stored in the internal request
cache. This does not affect `require_fresh`, i.e. if a cached result is
available, it is used.
The `timeout` can be used to restrict the time to wait for a
response. If the timeout triggers, :class:`TimeoutError` is raised.
If :meth:`~.Client.send` raises an
exception, all queries which were running simultanously for the same
target re-raise that exception. The result is not cached though. If a
new query is sent at a later point for the same target, a new query is
actually sent, independent of the value chosen for `require_fresh`.
.. versionchanged:: 0.9
The `no_cache` argument was added. | [
"Query",
"the",
"features",
"and",
"identities",
"of",
"the",
"specified",
"entity",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/disco/service.py#L644-L746 |
741 | horazont/aioxmpp | aioxmpp/disco/service.py | DiscoClient.query_items | def query_items(self, jid, *,
node=None, require_fresh=False, timeout=None):
"""
Query the items of the specified entity.
:param jid: The entity to query.
:type jid: :class:`aioxmpp.JID`
:param node: The node to query.
:type node: :class:`str` or :data:`None`
:param require_fresh: Boolean flag to discard previous caches.
:type require_fresh: :class:`bool`
:param timeout: Optional timeout for the response.
:type timeout: :class:`float`
:rtype: :class:`.xso.ItemsQuery`
:return: Service discovery items of the `node` at `jid`.
The arguments have the same semantics as with :meth:`query_info`, as
does the caching and error handling.
"""
key = jid, node
if not require_fresh:
try:
request = self._items_pending[key]
except KeyError:
pass
else:
try:
return (yield from request)
except asyncio.CancelledError:
pass
request_iq = stanza.IQ(to=jid, type_=structs.IQType.GET)
request_iq.payload = disco_xso.ItemsQuery(node=node)
request = asyncio.ensure_future(
self.client.send(request_iq)
)
self._items_pending[key] = request
try:
if timeout is not None:
try:
result = yield from asyncio.wait_for(
request,
timeout=timeout)
except asyncio.TimeoutError:
raise TimeoutError()
else:
result = yield from request
except: # NOQA
if request.done():
try:
pending = self._items_pending[key]
except KeyError:
pass
else:
if pending is request:
del self._items_pending[key]
raise
return result | python | def query_items(self, jid, *,
node=None, require_fresh=False, timeout=None):
key = jid, node
if not require_fresh:
try:
request = self._items_pending[key]
except KeyError:
pass
else:
try:
return (yield from request)
except asyncio.CancelledError:
pass
request_iq = stanza.IQ(to=jid, type_=structs.IQType.GET)
request_iq.payload = disco_xso.ItemsQuery(node=node)
request = asyncio.ensure_future(
self.client.send(request_iq)
)
self._items_pending[key] = request
try:
if timeout is not None:
try:
result = yield from asyncio.wait_for(
request,
timeout=timeout)
except asyncio.TimeoutError:
raise TimeoutError()
else:
result = yield from request
except: # NOQA
if request.done():
try:
pending = self._items_pending[key]
except KeyError:
pass
else:
if pending is request:
del self._items_pending[key]
raise
return result | [
"def",
"query_items",
"(",
"self",
",",
"jid",
",",
"*",
",",
"node",
"=",
"None",
",",
"require_fresh",
"=",
"False",
",",
"timeout",
"=",
"None",
")",
":",
"key",
"=",
"jid",
",",
"node",
"if",
"not",
"require_fresh",
":",
"try",
":",
"request",
"=",
"self",
".",
"_items_pending",
"[",
"key",
"]",
"except",
"KeyError",
":",
"pass",
"else",
":",
"try",
":",
"return",
"(",
"yield",
"from",
"request",
")",
"except",
"asyncio",
".",
"CancelledError",
":",
"pass",
"request_iq",
"=",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"structs",
".",
"IQType",
".",
"GET",
")",
"request_iq",
".",
"payload",
"=",
"disco_xso",
".",
"ItemsQuery",
"(",
"node",
"=",
"node",
")",
"request",
"=",
"asyncio",
".",
"ensure_future",
"(",
"self",
".",
"client",
".",
"send",
"(",
"request_iq",
")",
")",
"self",
".",
"_items_pending",
"[",
"key",
"]",
"=",
"request",
"try",
":",
"if",
"timeout",
"is",
"not",
"None",
":",
"try",
":",
"result",
"=",
"yield",
"from",
"asyncio",
".",
"wait_for",
"(",
"request",
",",
"timeout",
"=",
"timeout",
")",
"except",
"asyncio",
".",
"TimeoutError",
":",
"raise",
"TimeoutError",
"(",
")",
"else",
":",
"result",
"=",
"yield",
"from",
"request",
"except",
":",
"# NOQA",
"if",
"request",
".",
"done",
"(",
")",
":",
"try",
":",
"pending",
"=",
"self",
".",
"_items_pending",
"[",
"key",
"]",
"except",
"KeyError",
":",
"pass",
"else",
":",
"if",
"pending",
"is",
"request",
":",
"del",
"self",
".",
"_items_pending",
"[",
"key",
"]",
"raise",
"return",
"result"
] | Query the items of the specified entity.
:param jid: The entity to query.
:type jid: :class:`aioxmpp.JID`
:param node: The node to query.
:type node: :class:`str` or :data:`None`
:param require_fresh: Boolean flag to discard previous caches.
:type require_fresh: :class:`bool`
:param timeout: Optional timeout for the response.
:type timeout: :class:`float`
:rtype: :class:`.xso.ItemsQuery`
:return: Service discovery items of the `node` at `jid`.
The arguments have the same semantics as with :meth:`query_info`, as
does the caching and error handling. | [
"Query",
"the",
"items",
"of",
"the",
"specified",
"entity",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/disco/service.py#L749-L810 |
742 | horazont/aioxmpp | aioxmpp/roster/service.py | RosterClient.export_as_json | def export_as_json(self):
"""
Export the whole roster as currently stored on the client side into a
JSON-compatible dictionary and return that dictionary.
"""
return {
"items": {
str(jid): item.export_as_json()
for jid, item in self.items.items()
},
"ver": self.version
} | python | def export_as_json(self):
return {
"items": {
str(jid): item.export_as_json()
for jid, item in self.items.items()
},
"ver": self.version
} | [
"def",
"export_as_json",
"(",
"self",
")",
":",
"return",
"{",
"\"items\"",
":",
"{",
"str",
"(",
"jid",
")",
":",
"item",
".",
"export_as_json",
"(",
")",
"for",
"jid",
",",
"item",
"in",
"self",
".",
"items",
".",
"items",
"(",
")",
"}",
",",
"\"ver\"",
":",
"self",
".",
"version",
"}"
] | Export the whole roster as currently stored on the client side into a
JSON-compatible dictionary and return that dictionary. | [
"Export",
"the",
"whole",
"roster",
"as",
"currently",
"stored",
"on",
"the",
"client",
"side",
"into",
"a",
"JSON",
"-",
"compatible",
"dictionary",
"and",
"return",
"that",
"dictionary",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/roster/service.py#L574-L585 |
743 | horazont/aioxmpp | aioxmpp/roster/service.py | RosterClient.set_entry | def set_entry(self, jid, *,
name=_Sentinel,
add_to_groups=frozenset(),
remove_from_groups=frozenset(),
timeout=None):
"""
Set properties of a roster entry or add a new roster entry. The roster
entry is identified by its bare `jid`.
If an entry already exists, all values default to those stored in the
existing entry. For example, if no `name` is given, the current name of
the entry is re-used, if any.
If the entry does not exist, it will be created on the server side.
The `remove_from_groups` and `add_to_groups` arguments have to be based
on the locally cached state, as XMPP does not support sending
diffs. `remove_from_groups` takes precedence over `add_to_groups`.
`timeout` is the time in seconds to wait for a confirmation by the
server.
Note that the changes may not be visible immediately after his
coroutine returns in the :attr:`items` and :attr:`groups`
attributes. The :class:`Service` waits for the "official" roster push
from the server for updating the data structures and firing events, to
ensure that consistent state with other clients is achieved.
This may raise arbitrary :class:`.errors.XMPPError` exceptions if the
server replies with an error and also any kind of connection error if
the connection gets fatally terminated while waiting for a response.
"""
existing = self.items.get(jid, Item(jid))
post_groups = (existing.groups | add_to_groups) - remove_from_groups
post_name = existing.name
if name is not _Sentinel:
post_name = name
item = roster_xso.Item(
jid=jid,
name=post_name,
groups=[
roster_xso.Group(name=group_name)
for group_name in post_groups
])
yield from self.client.send(
stanza.IQ(
structs.IQType.SET,
payload=roster_xso.Query(items=[
item
])
),
timeout=timeout
) | python | def set_entry(self, jid, *,
name=_Sentinel,
add_to_groups=frozenset(),
remove_from_groups=frozenset(),
timeout=None):
existing = self.items.get(jid, Item(jid))
post_groups = (existing.groups | add_to_groups) - remove_from_groups
post_name = existing.name
if name is not _Sentinel:
post_name = name
item = roster_xso.Item(
jid=jid,
name=post_name,
groups=[
roster_xso.Group(name=group_name)
for group_name in post_groups
])
yield from self.client.send(
stanza.IQ(
structs.IQType.SET,
payload=roster_xso.Query(items=[
item
])
),
timeout=timeout
) | [
"def",
"set_entry",
"(",
"self",
",",
"jid",
",",
"*",
",",
"name",
"=",
"_Sentinel",
",",
"add_to_groups",
"=",
"frozenset",
"(",
")",
",",
"remove_from_groups",
"=",
"frozenset",
"(",
")",
",",
"timeout",
"=",
"None",
")",
":",
"existing",
"=",
"self",
".",
"items",
".",
"get",
"(",
"jid",
",",
"Item",
"(",
"jid",
")",
")",
"post_groups",
"=",
"(",
"existing",
".",
"groups",
"|",
"add_to_groups",
")",
"-",
"remove_from_groups",
"post_name",
"=",
"existing",
".",
"name",
"if",
"name",
"is",
"not",
"_Sentinel",
":",
"post_name",
"=",
"name",
"item",
"=",
"roster_xso",
".",
"Item",
"(",
"jid",
"=",
"jid",
",",
"name",
"=",
"post_name",
",",
"groups",
"=",
"[",
"roster_xso",
".",
"Group",
"(",
"name",
"=",
"group_name",
")",
"for",
"group_name",
"in",
"post_groups",
"]",
")",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"stanza",
".",
"IQ",
"(",
"structs",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"roster_xso",
".",
"Query",
"(",
"items",
"=",
"[",
"item",
"]",
")",
")",
",",
"timeout",
"=",
"timeout",
")"
] | Set properties of a roster entry or add a new roster entry. The roster
entry is identified by its bare `jid`.
If an entry already exists, all values default to those stored in the
existing entry. For example, if no `name` is given, the current name of
the entry is re-used, if any.
If the entry does not exist, it will be created on the server side.
The `remove_from_groups` and `add_to_groups` arguments have to be based
on the locally cached state, as XMPP does not support sending
diffs. `remove_from_groups` takes precedence over `add_to_groups`.
`timeout` is the time in seconds to wait for a confirmation by the
server.
Note that the changes may not be visible immediately after his
coroutine returns in the :attr:`items` and :attr:`groups`
attributes. The :class:`Service` waits for the "official" roster push
from the server for updating the data structures and firing events, to
ensure that consistent state with other clients is achieved.
This may raise arbitrary :class:`.errors.XMPPError` exceptions if the
server replies with an error and also any kind of connection error if
the connection gets fatally terminated while waiting for a response. | [
"Set",
"properties",
"of",
"a",
"roster",
"entry",
"or",
"add",
"a",
"new",
"roster",
"entry",
".",
"The",
"roster",
"entry",
"is",
"identified",
"by",
"its",
"bare",
"jid",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/roster/service.py#L612-L668 |
744 | horazont/aioxmpp | aioxmpp/roster/service.py | RosterClient.remove_entry | def remove_entry(self, jid, *, timeout=None):
"""
Request removal of the roster entry identified by the given bare
`jid`. If the entry currently has any subscription state, the server
will send the corresponding unsubscribing presence stanzas.
`timeout` is the maximum time in seconds to wait for a reply from the
server.
This may raise arbitrary :class:`.errors.XMPPError` exceptions if the
server replies with an error and also any kind of connection error if
the connection gets fatally terminated while waiting for a response.
"""
yield from self.client.send(
stanza.IQ(
structs.IQType.SET,
payload=roster_xso.Query(items=[
roster_xso.Item(
jid=jid,
subscription="remove"
)
])
),
timeout=timeout
) | python | def remove_entry(self, jid, *, timeout=None):
yield from self.client.send(
stanza.IQ(
structs.IQType.SET,
payload=roster_xso.Query(items=[
roster_xso.Item(
jid=jid,
subscription="remove"
)
])
),
timeout=timeout
) | [
"def",
"remove_entry",
"(",
"self",
",",
"jid",
",",
"*",
",",
"timeout",
"=",
"None",
")",
":",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"stanza",
".",
"IQ",
"(",
"structs",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"roster_xso",
".",
"Query",
"(",
"items",
"=",
"[",
"roster_xso",
".",
"Item",
"(",
"jid",
"=",
"jid",
",",
"subscription",
"=",
"\"remove\"",
")",
"]",
")",
")",
",",
"timeout",
"=",
"timeout",
")"
] | Request removal of the roster entry identified by the given bare
`jid`. If the entry currently has any subscription state, the server
will send the corresponding unsubscribing presence stanzas.
`timeout` is the maximum time in seconds to wait for a reply from the
server.
This may raise arbitrary :class:`.errors.XMPPError` exceptions if the
server replies with an error and also any kind of connection error if
the connection gets fatally terminated while waiting for a response. | [
"Request",
"removal",
"of",
"the",
"roster",
"entry",
"identified",
"by",
"the",
"given",
"bare",
"jid",
".",
"If",
"the",
"entry",
"currently",
"has",
"any",
"subscription",
"state",
"the",
"server",
"will",
"send",
"the",
"corresponding",
"unsubscribing",
"presence",
"stanzas",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/roster/service.py#L671-L695 |
745 | horazont/aioxmpp | aioxmpp/roster/service.py | RosterClient.subscribe | def subscribe(self, peer_jid):
"""
Request presence subscription with the given `peer_jid`.
This is deliberately not a coroutine; we don’t know whether the peer is
online (usually) and they may defer the confirmation very long, if they
confirm at all. Use :meth:`on_subscribed` to get notified when a peer
accepted a subscription request.
"""
self.client.enqueue(
stanza.Presence(type_=structs.PresenceType.SUBSCRIBE,
to=peer_jid)
) | python | def subscribe(self, peer_jid):
self.client.enqueue(
stanza.Presence(type_=structs.PresenceType.SUBSCRIBE,
to=peer_jid)
) | [
"def",
"subscribe",
"(",
"self",
",",
"peer_jid",
")",
":",
"self",
".",
"client",
".",
"enqueue",
"(",
"stanza",
".",
"Presence",
"(",
"type_",
"=",
"structs",
".",
"PresenceType",
".",
"SUBSCRIBE",
",",
"to",
"=",
"peer_jid",
")",
")"
] | Request presence subscription with the given `peer_jid`.
This is deliberately not a coroutine; we don’t know whether the peer is
online (usually) and they may defer the confirmation very long, if they
confirm at all. Use :meth:`on_subscribed` to get notified when a peer
accepted a subscription request. | [
"Request",
"presence",
"subscription",
"with",
"the",
"given",
"peer_jid",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/roster/service.py#L721-L733 |
746 | horazont/aioxmpp | aioxmpp/roster/service.py | RosterClient.unsubscribe | def unsubscribe(self, peer_jid):
"""
Unsubscribe from the presence of the given `peer_jid`.
"""
self.client.enqueue(
stanza.Presence(type_=structs.PresenceType.UNSUBSCRIBE,
to=peer_jid)
) | python | def unsubscribe(self, peer_jid):
self.client.enqueue(
stanza.Presence(type_=structs.PresenceType.UNSUBSCRIBE,
to=peer_jid)
) | [
"def",
"unsubscribe",
"(",
"self",
",",
"peer_jid",
")",
":",
"self",
".",
"client",
".",
"enqueue",
"(",
"stanza",
".",
"Presence",
"(",
"type_",
"=",
"structs",
".",
"PresenceType",
".",
"UNSUBSCRIBE",
",",
"to",
"=",
"peer_jid",
")",
")"
] | Unsubscribe from the presence of the given `peer_jid`. | [
"Unsubscribe",
"from",
"the",
"presence",
"of",
"the",
"given",
"peer_jid",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/roster/service.py#L735-L742 |
747 | horazont/aioxmpp | aioxmpp/dispatcher.py | message_handler | def message_handler(type_, from_):
"""
Register the decorated function as message handler.
:param type_: Message type to listen for
:type type_: :class:`~.MessageType`
:param from_: Sender JIDs to listen for
:type from_: :class:`aioxmpp.JID` or :data:`None`
:raise TypeError: if the decorated object is a coroutine function
.. seealso::
:meth:`~.StanzaStream.register_message_callback`
for more details on the `type_` and `from_` arguments
.. versionchanged:: 0.9
This is now based on
:class:`aioxmpp.dispatcher.SimpleMessageDispatcher`.
"""
def decorator(f):
if asyncio.iscoroutinefunction(f):
raise TypeError("message_handler must not be a coroutine function")
aioxmpp.service.add_handler_spec(
f,
aioxmpp.service.HandlerSpec(
(_apply_message_handler, (type_, from_)),
require_deps=(
SimpleMessageDispatcher,
)
)
)
return f
return decorator | python | def message_handler(type_, from_):
def decorator(f):
if asyncio.iscoroutinefunction(f):
raise TypeError("message_handler must not be a coroutine function")
aioxmpp.service.add_handler_spec(
f,
aioxmpp.service.HandlerSpec(
(_apply_message_handler, (type_, from_)),
require_deps=(
SimpleMessageDispatcher,
)
)
)
return f
return decorator | [
"def",
"message_handler",
"(",
"type_",
",",
"from_",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"if",
"asyncio",
".",
"iscoroutinefunction",
"(",
"f",
")",
":",
"raise",
"TypeError",
"(",
"\"message_handler must not be a coroutine function\"",
")",
"aioxmpp",
".",
"service",
".",
"add_handler_spec",
"(",
"f",
",",
"aioxmpp",
".",
"service",
".",
"HandlerSpec",
"(",
"(",
"_apply_message_handler",
",",
"(",
"type_",
",",
"from_",
")",
")",
",",
"require_deps",
"=",
"(",
"SimpleMessageDispatcher",
",",
")",
")",
")",
"return",
"f",
"return",
"decorator"
] | Register the decorated function as message handler.
:param type_: Message type to listen for
:type type_: :class:`~.MessageType`
:param from_: Sender JIDs to listen for
:type from_: :class:`aioxmpp.JID` or :data:`None`
:raise TypeError: if the decorated object is a coroutine function
.. seealso::
:meth:`~.StanzaStream.register_message_callback`
for more details on the `type_` and `from_` arguments
.. versionchanged:: 0.9
This is now based on
:class:`aioxmpp.dispatcher.SimpleMessageDispatcher`. | [
"Register",
"the",
"decorated",
"function",
"as",
"message",
"handler",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/dispatcher.py#L338-L373 |
748 | horazont/aioxmpp | aioxmpp/dispatcher.py | presence_handler | def presence_handler(type_, from_):
"""
Register the decorated function as presence stanza handler.
:param type_: Presence type to listen for
:type type_: :class:`~.PresenceType`
:param from_: Sender JIDs to listen for
:type from_: :class:`aioxmpp.JID` or :data:`None`
:raise TypeError: if the decorated object is a coroutine function
.. seealso::
:meth:`~.StanzaStream.register_presence_callback`
for more details on the `type_` and `from_` arguments
.. versionchanged:: 0.9
This is now based on
:class:`aioxmpp.dispatcher.SimplePresenceDispatcher`.
"""
def decorator(f):
if asyncio.iscoroutinefunction(f):
raise TypeError(
"presence_handler must not be a coroutine function"
)
aioxmpp.service.add_handler_spec(
f,
aioxmpp.service.HandlerSpec(
(_apply_presence_handler, (type_, from_)),
require_deps=(
SimplePresenceDispatcher,
)
)
)
return f
return decorator | python | def presence_handler(type_, from_):
def decorator(f):
if asyncio.iscoroutinefunction(f):
raise TypeError(
"presence_handler must not be a coroutine function"
)
aioxmpp.service.add_handler_spec(
f,
aioxmpp.service.HandlerSpec(
(_apply_presence_handler, (type_, from_)),
require_deps=(
SimplePresenceDispatcher,
)
)
)
return f
return decorator | [
"def",
"presence_handler",
"(",
"type_",
",",
"from_",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"if",
"asyncio",
".",
"iscoroutinefunction",
"(",
"f",
")",
":",
"raise",
"TypeError",
"(",
"\"presence_handler must not be a coroutine function\"",
")",
"aioxmpp",
".",
"service",
".",
"add_handler_spec",
"(",
"f",
",",
"aioxmpp",
".",
"service",
".",
"HandlerSpec",
"(",
"(",
"_apply_presence_handler",
",",
"(",
"type_",
",",
"from_",
")",
")",
",",
"require_deps",
"=",
"(",
"SimplePresenceDispatcher",
",",
")",
")",
")",
"return",
"f",
"return",
"decorator"
] | Register the decorated function as presence stanza handler.
:param type_: Presence type to listen for
:type type_: :class:`~.PresenceType`
:param from_: Sender JIDs to listen for
:type from_: :class:`aioxmpp.JID` or :data:`None`
:raise TypeError: if the decorated object is a coroutine function
.. seealso::
:meth:`~.StanzaStream.register_presence_callback`
for more details on the `type_` and `from_` arguments
.. versionchanged:: 0.9
This is now based on
:class:`aioxmpp.dispatcher.SimplePresenceDispatcher`. | [
"Register",
"the",
"decorated",
"function",
"as",
"presence",
"stanza",
"handler",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/dispatcher.py#L376-L413 |
749 | horazont/aioxmpp | aioxmpp/dispatcher.py | SimpleStanzaDispatcher._feed | def _feed(self, stanza):
"""
Dispatch the given `stanza`.
:param stanza: Stanza to dispatch
:type stanza: :class:`~.StanzaBase`
:rtype: :class:`bool`
:return: true if the stanza was dispatched, false otherwise.
Dispatch the stanza to up to one handler registered on the dispatcher.
If no handler is found for the stanza, :data:`False` is returned.
Otherwise, :data:`True` is returned.
"""
from_ = stanza.from_
if from_ is None:
from_ = self.local_jid
keys = [
(stanza.type_, from_, False),
(stanza.type_, from_.bare(), True),
(None, from_, False),
(None, from_.bare(), True),
(stanza.type_, None, False),
(None, from_, False),
(None, None, False),
]
for key in keys:
try:
cb = self._map[key]
except KeyError:
continue
cb(stanza)
return | python | def _feed(self, stanza):
from_ = stanza.from_
if from_ is None:
from_ = self.local_jid
keys = [
(stanza.type_, from_, False),
(stanza.type_, from_.bare(), True),
(None, from_, False),
(None, from_.bare(), True),
(stanza.type_, None, False),
(None, from_, False),
(None, None, False),
]
for key in keys:
try:
cb = self._map[key]
except KeyError:
continue
cb(stanza)
return | [
"def",
"_feed",
"(",
"self",
",",
"stanza",
")",
":",
"from_",
"=",
"stanza",
".",
"from_",
"if",
"from_",
"is",
"None",
":",
"from_",
"=",
"self",
".",
"local_jid",
"keys",
"=",
"[",
"(",
"stanza",
".",
"type_",
",",
"from_",
",",
"False",
")",
",",
"(",
"stanza",
".",
"type_",
",",
"from_",
".",
"bare",
"(",
")",
",",
"True",
")",
",",
"(",
"None",
",",
"from_",
",",
"False",
")",
",",
"(",
"None",
",",
"from_",
".",
"bare",
"(",
")",
",",
"True",
")",
",",
"(",
"stanza",
".",
"type_",
",",
"None",
",",
"False",
")",
",",
"(",
"None",
",",
"from_",
",",
"False",
")",
",",
"(",
"None",
",",
"None",
",",
"False",
")",
",",
"]",
"for",
"key",
"in",
"keys",
":",
"try",
":",
"cb",
"=",
"self",
".",
"_map",
"[",
"key",
"]",
"except",
"KeyError",
":",
"continue",
"cb",
"(",
"stanza",
")",
"return"
] | Dispatch the given `stanza`.
:param stanza: Stanza to dispatch
:type stanza: :class:`~.StanzaBase`
:rtype: :class:`bool`
:return: true if the stanza was dispatched, false otherwise.
Dispatch the stanza to up to one handler registered on the dispatcher.
If no handler is found for the stanza, :data:`False` is returned.
Otherwise, :data:`True` is returned. | [
"Dispatch",
"the",
"given",
"stanza",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/dispatcher.py#L103-L136 |
750 | horazont/aioxmpp | aioxmpp/dispatcher.py | SimpleStanzaDispatcher.register_callback | def register_callback(self, type_, from_, cb, *,
wildcard_resource=True):
"""
Register a callback function.
:param type_: Stanza type to listen for, or :data:`None` for a
wildcard match.
:param from_: Sender to listen for, or :data:`None` for a full wildcard
match.
:type from_: :class:`aioxmpp.JID` or :data:`None`
:param cb: Callback function to register
:param wildcard_resource: Whether to wildcard the resourcepart of the
JID.
:type wildcard_resource: :class:`bool`
:raises ValueError: if another function is already registered for the
callback slot.
`cb` will be called whenever a stanza with the matching `type_` and
`from_` is processed. The following wildcarding rules apply:
1. If the :attr:`~aioxmpp.stanza.StanzaBase.from_` attribute of the
stanza has a resourcepart, the following lookup order for callbacks is used:
+---------------------------+----------------------------------+----------------------+
|``type_`` |``from_`` |``wildcard_resource`` |
+===========================+==================================+======================+
|:attr:`~.StanzaBase.type_` |:attr:`~.StanzaBase.from_` |*any* |
+---------------------------+----------------------------------+----------------------+
|:attr:`~.StanzaBase.type_` |*bare* :attr:`~.StanzaBase.from_` |:data:`True` |
+---------------------------+----------------------------------+----------------------+
|:data:`None` |:attr:`~.StanzaBase.from_` |*any* |
+---------------------------+----------------------------------+----------------------+
|:data:`None` |*bare* :attr:`~.StanzaBase.from_` |:data:`True` |
+---------------------------+----------------------------------+----------------------+
|:attr:`~.StanzaBase.type_` |:data:`None` |*any* |
+---------------------------+----------------------------------+----------------------+
|:data:`None` |:data:`None` |*any* |
+---------------------------+----------------------------------+----------------------+
2. If the :attr:`~aioxmpp.stanza.StanzaBase.from_` attribute of the
stanza does *not* have a resourcepart, the following lookup order
for callbacks is used:
+---------------------------+---------------------------+----------------------+
|``type_`` |``from_`` |``wildcard_resource`` |
+===========================+===========================+======================+
|:attr:`~.StanzaBase.type_` |:attr:`~.StanzaBase.from_` |:data:`False` |
+---------------------------+---------------------------+----------------------+
|:data:`None` |:attr:`~.StanzaBase.from_` |:data:`False` |
+---------------------------+---------------------------+----------------------+
|:attr:`~.StanzaBase.type_` |:data:`None` |*any* |
+---------------------------+---------------------------+----------------------+
|:data:`None` |:data:`None` |*any* |
+---------------------------+---------------------------+----------------------+
Only the first callback which matches is called. `wildcard_resource` is
ignored if `from_` is a full JID or :data:`None`.
.. note::
When the server sends a stanza without from attribute, it is
replaced with the bare :attr:`local_jid`, as per :rfc:`6120`.
""" # NOQA: E501
if from_ is None or not from_.is_bare:
wildcard_resource = False
key = (type_, from_, wildcard_resource)
if key in self._map:
raise ValueError(
"only one listener allowed per matcher"
)
self._map[type_, from_, wildcard_resource] = cb | python | def register_callback(self, type_, from_, cb, *,
wildcard_resource=True):
# NOQA: E501
if from_ is None or not from_.is_bare:
wildcard_resource = False
key = (type_, from_, wildcard_resource)
if key in self._map:
raise ValueError(
"only one listener allowed per matcher"
)
self._map[type_, from_, wildcard_resource] = cb | [
"def",
"register_callback",
"(",
"self",
",",
"type_",
",",
"from_",
",",
"cb",
",",
"*",
",",
"wildcard_resource",
"=",
"True",
")",
":",
"# NOQA: E501",
"if",
"from_",
"is",
"None",
"or",
"not",
"from_",
".",
"is_bare",
":",
"wildcard_resource",
"=",
"False",
"key",
"=",
"(",
"type_",
",",
"from_",
",",
"wildcard_resource",
")",
"if",
"key",
"in",
"self",
".",
"_map",
":",
"raise",
"ValueError",
"(",
"\"only one listener allowed per matcher\"",
")",
"self",
".",
"_map",
"[",
"type_",
",",
"from_",
",",
"wildcard_resource",
"]",
"=",
"cb"
] | Register a callback function.
:param type_: Stanza type to listen for, or :data:`None` for a
wildcard match.
:param from_: Sender to listen for, or :data:`None` for a full wildcard
match.
:type from_: :class:`aioxmpp.JID` or :data:`None`
:param cb: Callback function to register
:param wildcard_resource: Whether to wildcard the resourcepart of the
JID.
:type wildcard_resource: :class:`bool`
:raises ValueError: if another function is already registered for the
callback slot.
`cb` will be called whenever a stanza with the matching `type_` and
`from_` is processed. The following wildcarding rules apply:
1. If the :attr:`~aioxmpp.stanza.StanzaBase.from_` attribute of the
stanza has a resourcepart, the following lookup order for callbacks is used:
+---------------------------+----------------------------------+----------------------+
|``type_`` |``from_`` |``wildcard_resource`` |
+===========================+==================================+======================+
|:attr:`~.StanzaBase.type_` |:attr:`~.StanzaBase.from_` |*any* |
+---------------------------+----------------------------------+----------------------+
|:attr:`~.StanzaBase.type_` |*bare* :attr:`~.StanzaBase.from_` |:data:`True` |
+---------------------------+----------------------------------+----------------------+
|:data:`None` |:attr:`~.StanzaBase.from_` |*any* |
+---------------------------+----------------------------------+----------------------+
|:data:`None` |*bare* :attr:`~.StanzaBase.from_` |:data:`True` |
+---------------------------+----------------------------------+----------------------+
|:attr:`~.StanzaBase.type_` |:data:`None` |*any* |
+---------------------------+----------------------------------+----------------------+
|:data:`None` |:data:`None` |*any* |
+---------------------------+----------------------------------+----------------------+
2. If the :attr:`~aioxmpp.stanza.StanzaBase.from_` attribute of the
stanza does *not* have a resourcepart, the following lookup order
for callbacks is used:
+---------------------------+---------------------------+----------------------+
|``type_`` |``from_`` |``wildcard_resource`` |
+===========================+===========================+======================+
|:attr:`~.StanzaBase.type_` |:attr:`~.StanzaBase.from_` |:data:`False` |
+---------------------------+---------------------------+----------------------+
|:data:`None` |:attr:`~.StanzaBase.from_` |:data:`False` |
+---------------------------+---------------------------+----------------------+
|:attr:`~.StanzaBase.type_` |:data:`None` |*any* |
+---------------------------+---------------------------+----------------------+
|:data:`None` |:data:`None` |*any* |
+---------------------------+---------------------------+----------------------+
Only the first callback which matches is called. `wildcard_resource` is
ignored if `from_` is a full JID or :data:`None`.
.. note::
When the server sends a stanza without from attribute, it is
replaced with the bare :attr:`local_jid`, as per :rfc:`6120`. | [
"Register",
"a",
"callback",
"function",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/dispatcher.py#L138-L211 |
751 | horazont/aioxmpp | aioxmpp/dispatcher.py | SimpleStanzaDispatcher.unregister_callback | def unregister_callback(self, type_, from_, *,
wildcard_resource=True):
"""
Unregister a callback function.
:param type_: Stanza type to listen for, or :data:`None` for a
wildcard match.
:param from_: Sender to listen for, or :data:`None` for a full wildcard
match.
:type from_: :class:`aioxmpp.JID` or :data:`None`
:param wildcard_resource: Whether to wildcard the resourcepart of the
JID.
:type wildcard_resource: :class:`bool`
The callback must be disconnected with the same arguments as were used
to connect it.
"""
if from_ is None or not from_.is_bare:
wildcard_resource = False
self._map.pop((type_, from_, wildcard_resource)) | python | def unregister_callback(self, type_, from_, *,
wildcard_resource=True):
if from_ is None or not from_.is_bare:
wildcard_resource = False
self._map.pop((type_, from_, wildcard_resource)) | [
"def",
"unregister_callback",
"(",
"self",
",",
"type_",
",",
"from_",
",",
"*",
",",
"wildcard_resource",
"=",
"True",
")",
":",
"if",
"from_",
"is",
"None",
"or",
"not",
"from_",
".",
"is_bare",
":",
"wildcard_resource",
"=",
"False",
"self",
".",
"_map",
".",
"pop",
"(",
"(",
"type_",
",",
"from_",
",",
"wildcard_resource",
")",
")"
] | Unregister a callback function.
:param type_: Stanza type to listen for, or :data:`None` for a
wildcard match.
:param from_: Sender to listen for, or :data:`None` for a full wildcard
match.
:type from_: :class:`aioxmpp.JID` or :data:`None`
:param wildcard_resource: Whether to wildcard the resourcepart of the
JID.
:type wildcard_resource: :class:`bool`
The callback must be disconnected with the same arguments as were used
to connect it. | [
"Unregister",
"a",
"callback",
"function",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/dispatcher.py#L213-L233 |
752 | horazont/aioxmpp | aioxmpp/dispatcher.py | SimpleStanzaDispatcher.handler_context | def handler_context(self, type_, from_, cb, *, wildcard_resource=True):
"""
Context manager which temporarily registers a callback.
The arguments are the same as for :meth:`register_callback`.
When the context is entered, the callback `cb` is registered. When the
context is exited, no matter if an exception is raised or not, the
callback is unregistered.
"""
self.register_callback(
type_, from_, cb,
wildcard_resource=wildcard_resource
)
try:
yield
finally:
self.unregister_callback(
type_, from_,
wildcard_resource=wildcard_resource
) | python | def handler_context(self, type_, from_, cb, *, wildcard_resource=True):
self.register_callback(
type_, from_, cb,
wildcard_resource=wildcard_resource
)
try:
yield
finally:
self.unregister_callback(
type_, from_,
wildcard_resource=wildcard_resource
) | [
"def",
"handler_context",
"(",
"self",
",",
"type_",
",",
"from_",
",",
"cb",
",",
"*",
",",
"wildcard_resource",
"=",
"True",
")",
":",
"self",
".",
"register_callback",
"(",
"type_",
",",
"from_",
",",
"cb",
",",
"wildcard_resource",
"=",
"wildcard_resource",
")",
"try",
":",
"yield",
"finally",
":",
"self",
".",
"unregister_callback",
"(",
"type_",
",",
"from_",
",",
"wildcard_resource",
"=",
"wildcard_resource",
")"
] | Context manager which temporarily registers a callback.
The arguments are the same as for :meth:`register_callback`.
When the context is entered, the callback `cb` is registered. When the
context is exited, no matter if an exception is raised or not, the
callback is unregistered. | [
"Context",
"manager",
"which",
"temporarily",
"registers",
"a",
"callback",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/dispatcher.py#L236-L256 |
753 | horazont/aioxmpp | aioxmpp/forms/fields.py | BoundField.load | def load(self, field_xso):
"""
Load the field information from a data field.
:param field_xso: XSO describing the field.
:type field_xso: :class:`~.Field`
This loads the current value, description, label and possibly options
from the `field_xso`, shadowing the information from the declaration of
the field on the class.
This method is must be overriden and is thus marked abstract. However,
when called from a subclass, it loads the :attr:`desc`, :attr:`label`
and :attr:`required` from the given `field_xso`. Subclasses are
supposed to implement a mechansim to load options and/or values from
the `field_xso` and then call this implementation through
:func:`super`.
"""
if field_xso.desc:
self._desc = field_xso.desc
if field_xso.label:
self._label = field_xso.label
self._required = field_xso.required | python | def load(self, field_xso):
if field_xso.desc:
self._desc = field_xso.desc
if field_xso.label:
self._label = field_xso.label
self._required = field_xso.required | [
"def",
"load",
"(",
"self",
",",
"field_xso",
")",
":",
"if",
"field_xso",
".",
"desc",
":",
"self",
".",
"_desc",
"=",
"field_xso",
".",
"desc",
"if",
"field_xso",
".",
"label",
":",
"self",
".",
"_label",
"=",
"field_xso",
".",
"label",
"self",
".",
"_required",
"=",
"field_xso",
".",
"required"
] | Load the field information from a data field.
:param field_xso: XSO describing the field.
:type field_xso: :class:`~.Field`
This loads the current value, description, label and possibly options
from the `field_xso`, shadowing the information from the declaration of
the field on the class.
This method is must be overriden and is thus marked abstract. However,
when called from a subclass, it loads the :attr:`desc`, :attr:`label`
and :attr:`required` from the given `field_xso`. Subclasses are
supposed to implement a mechansim to load options and/or values from
the `field_xso` and then call this implementation through
:func:`super`. | [
"Load",
"the",
"field",
"information",
"from",
"a",
"data",
"field",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/forms/fields.py#L208-L232 |
754 | horazont/aioxmpp | aioxmpp/forms/fields.py | BoundMultiValueField.value | def value(self):
"""
A tuple of values. This attribute can be set with any iterable; the
iterable is then evaluated into a tuple and stored at the bound field.
Whenever values are written to this attribute, they are passed through
the :meth:`~.AbstractCDataType.coerce` method of the
:attr:`~.AbstractField.type_` of the field. To revert the
:attr:`value` to its default, use the ``del`` operator.
"""
try:
return self._value
except AttributeError:
self.value = self._field.default()
return self._value | python | def value(self):
try:
return self._value
except AttributeError:
self.value = self._field.default()
return self._value | [
"def",
"value",
"(",
"self",
")",
":",
"try",
":",
"return",
"self",
".",
"_value",
"except",
"AttributeError",
":",
"self",
".",
"value",
"=",
"self",
".",
"_field",
".",
"default",
"(",
")",
"return",
"self",
".",
"_value"
] | A tuple of values. This attribute can be set with any iterable; the
iterable is then evaluated into a tuple and stored at the bound field.
Whenever values are written to this attribute, they are passed through
the :meth:`~.AbstractCDataType.coerce` method of the
:attr:`~.AbstractField.type_` of the field. To revert the
:attr:`value` to its default, use the ``del`` operator. | [
"A",
"tuple",
"of",
"values",
".",
"This",
"attribute",
"can",
"be",
"set",
"with",
"any",
"iterable",
";",
"the",
"iterable",
"is",
"then",
"evaluated",
"into",
"a",
"tuple",
"and",
"stored",
"at",
"the",
"bound",
"field",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/forms/fields.py#L384-L398 |
755 | horazont/aioxmpp | aioxmpp/xml.py | write_single_xso | def write_single_xso(x, dest):
"""
Write a single XSO `x` to a binary file-like object `dest`.
"""
gen = XMPPXMLGenerator(dest,
short_empty_elements=True,
sorted_attributes=True)
x.unparse_to_sax(gen) | python | def write_single_xso(x, dest):
gen = XMPPXMLGenerator(dest,
short_empty_elements=True,
sorted_attributes=True)
x.unparse_to_sax(gen) | [
"def",
"write_single_xso",
"(",
"x",
",",
"dest",
")",
":",
"gen",
"=",
"XMPPXMLGenerator",
"(",
"dest",
",",
"short_empty_elements",
"=",
"True",
",",
"sorted_attributes",
"=",
"True",
")",
"x",
".",
"unparse_to_sax",
"(",
"gen",
")"
] | Write a single XSO `x` to a binary file-like object `dest`. | [
"Write",
"a",
"single",
"XSO",
"x",
"to",
"a",
"binary",
"file",
"-",
"like",
"object",
"dest",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L1112-L1119 |
756 | horazont/aioxmpp | aioxmpp/xml.py | read_xso | def read_xso(src, xsomap):
"""
Read a single XSO from a binary file-like input `src` containing an XML
document.
`xsomap` must be a mapping which maps :class:`~.XSO` subclasses
to callables. These will be registered at a newly created
:class:`.xso.XSOParser` instance which will be used to parse the document
in `src`.
The `xsomap` is thus used to determine the class parsing the root element
of the XML document. This can be used to support multiple versions.
"""
xso_parser = xso.XSOParser()
for class_, cb in xsomap.items():
xso_parser.add_class(class_, cb)
driver = xso.SAXDriver(xso_parser)
parser = xml.sax.make_parser()
parser.setFeature(
xml.sax.handler.feature_namespaces,
True)
parser.setFeature(
xml.sax.handler.feature_external_ges,
False)
parser.setContentHandler(driver)
parser.parse(src) | python | def read_xso(src, xsomap):
xso_parser = xso.XSOParser()
for class_, cb in xsomap.items():
xso_parser.add_class(class_, cb)
driver = xso.SAXDriver(xso_parser)
parser = xml.sax.make_parser()
parser.setFeature(
xml.sax.handler.feature_namespaces,
True)
parser.setFeature(
xml.sax.handler.feature_external_ges,
False)
parser.setContentHandler(driver)
parser.parse(src) | [
"def",
"read_xso",
"(",
"src",
",",
"xsomap",
")",
":",
"xso_parser",
"=",
"xso",
".",
"XSOParser",
"(",
")",
"for",
"class_",
",",
"cb",
"in",
"xsomap",
".",
"items",
"(",
")",
":",
"xso_parser",
".",
"add_class",
"(",
"class_",
",",
"cb",
")",
"driver",
"=",
"xso",
".",
"SAXDriver",
"(",
"xso_parser",
")",
"parser",
"=",
"xml",
".",
"sax",
".",
"make_parser",
"(",
")",
"parser",
".",
"setFeature",
"(",
"xml",
".",
"sax",
".",
"handler",
".",
"feature_namespaces",
",",
"True",
")",
"parser",
".",
"setFeature",
"(",
"xml",
".",
"sax",
".",
"handler",
".",
"feature_external_ges",
",",
"False",
")",
"parser",
".",
"setContentHandler",
"(",
"driver",
")",
"parser",
".",
"parse",
"(",
"src",
")"
] | Read a single XSO from a binary file-like input `src` containing an XML
document.
`xsomap` must be a mapping which maps :class:`~.XSO` subclasses
to callables. These will be registered at a newly created
:class:`.xso.XSOParser` instance which will be used to parse the document
in `src`.
The `xsomap` is thus used to determine the class parsing the root element
of the XML document. This can be used to support multiple versions. | [
"Read",
"a",
"single",
"XSO",
"from",
"a",
"binary",
"file",
"-",
"like",
"input",
"src",
"containing",
"an",
"XML",
"document",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L1122-L1152 |
757 | horazont/aioxmpp | aioxmpp/xml.py | XMPPXMLGenerator.startPrefixMapping | def startPrefixMapping(self, prefix, uri, *, auto=False):
"""
Start a prefix mapping which maps the given `prefix` to the given
`uri`.
Note that prefix mappings are handled transactional. All announcements
of prefix mappings are collected until the next call to
:meth:`startElementNS`. At that point, the mappings are collected and
start to override the previously declared mappings until the
corresponding :meth:`endElementNS` call.
Also note that calling :meth:`startPrefixMapping` is not mandatory; you
can use any namespace you like at any time. If you use a namespace
whose URI has not been associated with a prefix yet, a free prefix will
automatically be chosen. To avoid unneccessary performance penalties,
do not use prefixes of the form ``"ns{:d}".format(n)``, for any
non-negative number of `n`.
It is however required to call :meth:`endPrefixMapping` after a
:meth:`endElementNS` call for all namespaces which have been announced
directly before the :meth:`startElementNS` call (except for those which
have been chosen automatically). Not doing so will result in a
:class:`RuntimeError` at the next :meth:`startElementNS` or
:meth:`endElementNS` call.
During a transaction, it is not allowed to declare the same prefix
multiple times.
"""
if (prefix is not None and
(prefix == "xml" or
prefix == "xmlns" or
not xmlValidateNameValue_str(prefix) or
":" in prefix)):
raise ValueError("not a valid prefix: {!r}".format(prefix))
if prefix in self._ns_prefixes_floating_in:
raise ValueError("prefix already declared for next element")
if auto:
self._ns_auto_prefixes_floating_in.add(prefix)
self._ns_prefixes_floating_in[prefix] = uri
self._ns_decls_floating_in[uri] = prefix | python | def startPrefixMapping(self, prefix, uri, *, auto=False):
if (prefix is not None and
(prefix == "xml" or
prefix == "xmlns" or
not xmlValidateNameValue_str(prefix) or
":" in prefix)):
raise ValueError("not a valid prefix: {!r}".format(prefix))
if prefix in self._ns_prefixes_floating_in:
raise ValueError("prefix already declared for next element")
if auto:
self._ns_auto_prefixes_floating_in.add(prefix)
self._ns_prefixes_floating_in[prefix] = uri
self._ns_decls_floating_in[uri] = prefix | [
"def",
"startPrefixMapping",
"(",
"self",
",",
"prefix",
",",
"uri",
",",
"*",
",",
"auto",
"=",
"False",
")",
":",
"if",
"(",
"prefix",
"is",
"not",
"None",
"and",
"(",
"prefix",
"==",
"\"xml\"",
"or",
"prefix",
"==",
"\"xmlns\"",
"or",
"not",
"xmlValidateNameValue_str",
"(",
"prefix",
")",
"or",
"\":\"",
"in",
"prefix",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"not a valid prefix: {!r}\"",
".",
"format",
"(",
"prefix",
")",
")",
"if",
"prefix",
"in",
"self",
".",
"_ns_prefixes_floating_in",
":",
"raise",
"ValueError",
"(",
"\"prefix already declared for next element\"",
")",
"if",
"auto",
":",
"self",
".",
"_ns_auto_prefixes_floating_in",
".",
"add",
"(",
"prefix",
")",
"self",
".",
"_ns_prefixes_floating_in",
"[",
"prefix",
"]",
"=",
"uri",
"self",
".",
"_ns_decls_floating_in",
"[",
"uri",
"]",
"=",
"prefix"
] | Start a prefix mapping which maps the given `prefix` to the given
`uri`.
Note that prefix mappings are handled transactional. All announcements
of prefix mappings are collected until the next call to
:meth:`startElementNS`. At that point, the mappings are collected and
start to override the previously declared mappings until the
corresponding :meth:`endElementNS` call.
Also note that calling :meth:`startPrefixMapping` is not mandatory; you
can use any namespace you like at any time. If you use a namespace
whose URI has not been associated with a prefix yet, a free prefix will
automatically be chosen. To avoid unneccessary performance penalties,
do not use prefixes of the form ``"ns{:d}".format(n)``, for any
non-negative number of `n`.
It is however required to call :meth:`endPrefixMapping` after a
:meth:`endElementNS` call for all namespaces which have been announced
directly before the :meth:`startElementNS` call (except for those which
have been chosen automatically). Not doing so will result in a
:class:`RuntimeError` at the next :meth:`startElementNS` or
:meth:`endElementNS` call.
During a transaction, it is not allowed to declare the same prefix
multiple times. | [
"Start",
"a",
"prefix",
"mapping",
"which",
"maps",
"the",
"given",
"prefix",
"to",
"the",
"given",
"uri",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L348-L388 |
758 | horazont/aioxmpp | aioxmpp/xml.py | XMPPXMLGenerator.buffer | def buffer(self):
"""
Context manager to temporarily buffer the output.
:raise RuntimeError: If two :meth:`buffer` context managers are used
nestedly.
If the context manager is left without exception, the buffered output
is sent to the actual sink. Otherwise, it is discarded.
In addition to the output being buffered, buffer also captures the
entire state of the XML generator and restores it to the previous state
if the context manager is left with an exception.
This can be used to fail-safely attempt to serialise a subtree and
return to a well-defined state if serialisation fails.
:meth:`flush` is not called automatically.
If :meth:`flush` is called while a :meth:`buffer` context manager is
active, no actual flushing happens (but unfinished opening tags are
closed as usual, see the `short_empty_arguments` parameter).
"""
if self._buf_in_use:
raise RuntimeError("nested use of buffer() is not supported")
self._buf_in_use = True
old_write = self._write
old_flush = self._flush
if self._buf is None:
self._buf = io.BytesIO()
else:
try:
self._buf.seek(0)
self._buf.truncate()
except BufferError:
# we need a fresh buffer for this, the other is still in use.
self._buf = io.BytesIO()
self._write = self._buf.write
self._flush = None
try:
with self._save_state():
yield
old_write(self._buf.getbuffer())
if old_flush:
old_flush()
finally:
self._buf_in_use = False
self._write = old_write
self._flush = old_flush | python | def buffer(self):
if self._buf_in_use:
raise RuntimeError("nested use of buffer() is not supported")
self._buf_in_use = True
old_write = self._write
old_flush = self._flush
if self._buf is None:
self._buf = io.BytesIO()
else:
try:
self._buf.seek(0)
self._buf.truncate()
except BufferError:
# we need a fresh buffer for this, the other is still in use.
self._buf = io.BytesIO()
self._write = self._buf.write
self._flush = None
try:
with self._save_state():
yield
old_write(self._buf.getbuffer())
if old_flush:
old_flush()
finally:
self._buf_in_use = False
self._write = old_write
self._flush = old_flush | [
"def",
"buffer",
"(",
"self",
")",
":",
"if",
"self",
".",
"_buf_in_use",
":",
"raise",
"RuntimeError",
"(",
"\"nested use of buffer() is not supported\"",
")",
"self",
".",
"_buf_in_use",
"=",
"True",
"old_write",
"=",
"self",
".",
"_write",
"old_flush",
"=",
"self",
".",
"_flush",
"if",
"self",
".",
"_buf",
"is",
"None",
":",
"self",
".",
"_buf",
"=",
"io",
".",
"BytesIO",
"(",
")",
"else",
":",
"try",
":",
"self",
".",
"_buf",
".",
"seek",
"(",
"0",
")",
"self",
".",
"_buf",
".",
"truncate",
"(",
")",
"except",
"BufferError",
":",
"# we need a fresh buffer for this, the other is still in use.",
"self",
".",
"_buf",
"=",
"io",
".",
"BytesIO",
"(",
")",
"self",
".",
"_write",
"=",
"self",
".",
"_buf",
".",
"write",
"self",
".",
"_flush",
"=",
"None",
"try",
":",
"with",
"self",
".",
"_save_state",
"(",
")",
":",
"yield",
"old_write",
"(",
"self",
".",
"_buf",
".",
"getbuffer",
"(",
")",
")",
"if",
"old_flush",
":",
"old_flush",
"(",
")",
"finally",
":",
"self",
".",
"_buf_in_use",
"=",
"False",
"self",
".",
"_write",
"=",
"old_write",
"self",
".",
"_flush",
"=",
"old_flush"
] | Context manager to temporarily buffer the output.
:raise RuntimeError: If two :meth:`buffer` context managers are used
nestedly.
If the context manager is left without exception, the buffered output
is sent to the actual sink. Otherwise, it is discarded.
In addition to the output being buffered, buffer also captures the
entire state of the XML generator and restores it to the previous state
if the context manager is left with an exception.
This can be used to fail-safely attempt to serialise a subtree and
return to a well-defined state if serialisation fails.
:meth:`flush` is not called automatically.
If :meth:`flush` is called while a :meth:`buffer` context manager is
active, no actual flushing happens (but unfinished opening tags are
closed as usual, see the `short_empty_arguments` parameter). | [
"Context",
"manager",
"to",
"temporarily",
"buffer",
"the",
"output",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L594-L644 |
759 | horazont/aioxmpp | aioxmpp/xml.py | XMLStreamWriter.start | def start(self):
"""
Send the stream header as described above.
"""
attrs = {
(None, "to"): str(self._to),
(None, "version"): ".".join(map(str, self._version))
}
if self._from:
attrs[None, "from"] = str(self._from)
self._writer.startDocument()
for prefix, uri in self._nsmap_to_use.items():
self._writer.startPrefixMapping(prefix, uri)
self._writer.startElementNS(
(namespaces.xmlstream, "stream"),
None,
attrs)
self._writer.flush() | python | def start(self):
attrs = {
(None, "to"): str(self._to),
(None, "version"): ".".join(map(str, self._version))
}
if self._from:
attrs[None, "from"] = str(self._from)
self._writer.startDocument()
for prefix, uri in self._nsmap_to_use.items():
self._writer.startPrefixMapping(prefix, uri)
self._writer.startElementNS(
(namespaces.xmlstream, "stream"),
None,
attrs)
self._writer.flush() | [
"def",
"start",
"(",
"self",
")",
":",
"attrs",
"=",
"{",
"(",
"None",
",",
"\"to\"",
")",
":",
"str",
"(",
"self",
".",
"_to",
")",
",",
"(",
"None",
",",
"\"version\"",
")",
":",
"\".\"",
".",
"join",
"(",
"map",
"(",
"str",
",",
"self",
".",
"_version",
")",
")",
"}",
"if",
"self",
".",
"_from",
":",
"attrs",
"[",
"None",
",",
"\"from\"",
"]",
"=",
"str",
"(",
"self",
".",
"_from",
")",
"self",
".",
"_writer",
".",
"startDocument",
"(",
")",
"for",
"prefix",
",",
"uri",
"in",
"self",
".",
"_nsmap_to_use",
".",
"items",
"(",
")",
":",
"self",
".",
"_writer",
".",
"startPrefixMapping",
"(",
"prefix",
",",
"uri",
")",
"self",
".",
"_writer",
".",
"startElementNS",
"(",
"(",
"namespaces",
".",
"xmlstream",
",",
"\"stream\"",
")",
",",
"None",
",",
"attrs",
")",
"self",
".",
"_writer",
".",
"flush",
"(",
")"
] | Send the stream header as described above. | [
"Send",
"the",
"stream",
"header",
"as",
"described",
"above",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L718-L736 |
760 | horazont/aioxmpp | aioxmpp/xml.py | XMLStreamWriter.send | def send(self, xso):
"""
Send a single XML stream object.
:param xso: Object to serialise and send.
:type xso: :class:`aioxmpp.xso.XSO`
:raises Exception: from any serialisation errors, usually
:class:`ValueError`.
Serialise the `xso` and send it over the stream. If any serialisation
error occurs, no data is sent over the stream and the exception is
re-raised; the :meth:`send` method thus provides strong exception
safety.
.. warning::
The behaviour of :meth:`send` after :meth:`abort` or :meth:`close`
and before :meth:`start` is undefined.
"""
with self._writer.buffer():
xso.unparse_to_sax(self._writer) | python | def send(self, xso):
with self._writer.buffer():
xso.unparse_to_sax(self._writer) | [
"def",
"send",
"(",
"self",
",",
"xso",
")",
":",
"with",
"self",
".",
"_writer",
".",
"buffer",
"(",
")",
":",
"xso",
".",
"unparse_to_sax",
"(",
"self",
".",
"_writer",
")"
] | Send a single XML stream object.
:param xso: Object to serialise and send.
:type xso: :class:`aioxmpp.xso.XSO`
:raises Exception: from any serialisation errors, usually
:class:`ValueError`.
Serialise the `xso` and send it over the stream. If any serialisation
error occurs, no data is sent over the stream and the exception is
re-raised; the :meth:`send` method thus provides strong exception
safety.
.. warning::
The behaviour of :meth:`send` after :meth:`abort` or :meth:`close`
and before :meth:`start` is undefined. | [
"Send",
"a",
"single",
"XML",
"stream",
"object",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L738-L759 |
761 | horazont/aioxmpp | aioxmpp/xml.py | XMLStreamWriter.abort | def abort(self):
"""
Abort the stream.
The stream is flushed and the internal data structures are cleaned up.
No stream footer is sent. The stream is :attr:`closed` afterwards.
If the stream is already :attr:`closed`, this method does nothing.
"""
if self._closed:
return
self._closed = True
self._writer.flush()
del self._writer | python | def abort(self):
if self._closed:
return
self._closed = True
self._writer.flush()
del self._writer | [
"def",
"abort",
"(",
"self",
")",
":",
"if",
"self",
".",
"_closed",
":",
"return",
"self",
".",
"_closed",
"=",
"True",
"self",
".",
"_writer",
".",
"flush",
"(",
")",
"del",
"self",
".",
"_writer"
] | Abort the stream.
The stream is flushed and the internal data structures are cleaned up.
No stream footer is sent. The stream is :attr:`closed` afterwards.
If the stream is already :attr:`closed`, this method does nothing. | [
"Abort",
"the",
"stream",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/xml.py#L761-L774 |
762 | horazont/aioxmpp | aioxmpp/rsm/xso.py | ResultSetMetadata.fetch_page | def fetch_page(cls, index, max_=None):
"""
Return a query set which requests a specific page.
:param index: Index of the first element of the page to fetch.
:type index: :class:`int`
:param max_: Maximum number of elements to fetch
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request a page starting with the
element indexed by `index`.
.. note::
This way of retrieving items may be approximate. See :xep:`59` and
the embedding protocol for which RSM is used for specifics.
"""
result = cls()
result.index = index
result.max_ = max_
return result | python | def fetch_page(cls, index, max_=None):
result = cls()
result.index = index
result.max_ = max_
return result | [
"def",
"fetch_page",
"(",
"cls",
",",
"index",
",",
"max_",
"=",
"None",
")",
":",
"result",
"=",
"cls",
"(",
")",
"result",
".",
"index",
"=",
"index",
"result",
".",
"max_",
"=",
"max_",
"return",
"result"
] | Return a query set which requests a specific page.
:param index: Index of the first element of the page to fetch.
:type index: :class:`int`
:param max_: Maximum number of elements to fetch
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request a page starting with the
element indexed by `index`.
.. note::
This way of retrieving items may be approximate. See :xep:`59` and
the embedding protocol for which RSM is used for specifics. | [
"Return",
"a",
"query",
"set",
"which",
"requests",
"a",
"specific",
"page",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/rsm/xso.py#L193-L214 |
763 | horazont/aioxmpp | aioxmpp/rsm/xso.py | ResultSetMetadata.limit | def limit(self, max_):
"""
Limit the result set to a given number of items.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request at most `max_` items.
This method can be called on the class and on objects. When called on
objects, it returns a copy of the object with :attr:`max_` set
accordingly. When called on the class, it creates a fresh object with
:attr:`max_` set accordingly.
"""
if isinstance(self, type):
result = self()
else:
result = copy.deepcopy(self)
result.max_ = max_
return result | python | def limit(self, max_):
if isinstance(self, type):
result = self()
else:
result = copy.deepcopy(self)
result.max_ = max_
return result | [
"def",
"limit",
"(",
"self",
",",
"max_",
")",
":",
"if",
"isinstance",
"(",
"self",
",",
"type",
")",
":",
"result",
"=",
"self",
"(",
")",
"else",
":",
"result",
"=",
"copy",
".",
"deepcopy",
"(",
"self",
")",
"result",
".",
"max_",
"=",
"max_",
"return",
"result"
] | Limit the result set to a given number of items.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request at most `max_` items.
This method can be called on the class and on objects. When called on
objects, it returns a copy of the object with :attr:`max_` set
accordingly. When called on the class, it creates a fresh object with
:attr:`max_` set accordingly. | [
"Limit",
"the",
"result",
"set",
"to",
"a",
"given",
"number",
"of",
"items",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/rsm/xso.py#L217-L237 |
764 | horazont/aioxmpp | aioxmpp/rsm/xso.py | ResultSetMetadata.next_page | def next_page(self, max_=None):
"""
Return a query set which requests the page after this response.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request the next page.
Must be called on a result set which has :attr:`last` set.
"""
result = type(self)()
result.after = After(self.last.value)
result.max_ = max_
return result | python | def next_page(self, max_=None):
result = type(self)()
result.after = After(self.last.value)
result.max_ = max_
return result | [
"def",
"next_page",
"(",
"self",
",",
"max_",
"=",
"None",
")",
":",
"result",
"=",
"type",
"(",
"self",
")",
"(",
")",
"result",
".",
"after",
"=",
"After",
"(",
"self",
".",
"last",
".",
"value",
")",
"result",
".",
"max_",
"=",
"max_",
"return",
"result"
] | Return a query set which requests the page after this response.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request the next page.
Must be called on a result set which has :attr:`last` set. | [
"Return",
"a",
"query",
"set",
"which",
"requests",
"the",
"page",
"after",
"this",
"response",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/rsm/xso.py#L239-L254 |
765 | horazont/aioxmpp | aioxmpp/rsm/xso.py | ResultSetMetadata.previous_page | def previous_page(self, max_=None):
"""
Return a query set which requests the page before this response.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request the previous page.
Must be called on a result set which has :attr:`first` set.
"""
result = type(self)()
result.before = Before(self.first.value)
result.max_ = max_
return result | python | def previous_page(self, max_=None):
result = type(self)()
result.before = Before(self.first.value)
result.max_ = max_
return result | [
"def",
"previous_page",
"(",
"self",
",",
"max_",
"=",
"None",
")",
":",
"result",
"=",
"type",
"(",
"self",
")",
"(",
")",
"result",
".",
"before",
"=",
"Before",
"(",
"self",
".",
"first",
".",
"value",
")",
"result",
".",
"max_",
"=",
"max_",
"return",
"result"
] | Return a query set which requests the page before this response.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request the previous page.
Must be called on a result set which has :attr:`first` set. | [
"Return",
"a",
"query",
"set",
"which",
"requests",
"the",
"page",
"before",
"this",
"response",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/rsm/xso.py#L256-L271 |
766 | horazont/aioxmpp | aioxmpp/rsm/xso.py | ResultSetMetadata.last_page | def last_page(self_or_cls, max_=None):
"""
Return a query set which requests the last page.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request the last page.
"""
result = self_or_cls()
result.before = Before()
result.max_ = max_
return result | python | def last_page(self_or_cls, max_=None):
result = self_or_cls()
result.before = Before()
result.max_ = max_
return result | [
"def",
"last_page",
"(",
"self_or_cls",
",",
"max_",
"=",
"None",
")",
":",
"result",
"=",
"self_or_cls",
"(",
")",
"result",
".",
"before",
"=",
"Before",
"(",
")",
"result",
".",
"max_",
"=",
"max_",
"return",
"result"
] | Return a query set which requests the last page.
:param max_: Maximum number of items to return.
:type max_: :class:`int` or :data:`None`
:rtype: :class:`ResultSetMetadata`
:return: A new request set up to request the last page. | [
"Return",
"a",
"query",
"set",
"which",
"requests",
"the",
"last",
"page",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/rsm/xso.py#L274-L286 |
767 | horazont/aioxmpp | aioxmpp/forms/xso.py | FieldType.allow_upcast | def allow_upcast(self, to):
"""
Return true if the field type may be upcast to the other field type
`to`.
This relation specifies when it is safe to transfer data from this
field type to the given other field type `to`.
This is the case if any of the following holds true:
* `to` is equal to this type
* this type is :attr:`TEXT_SINGLE` and `to` is :attr:`TEXT_PRIVATE`
"""
if self == to:
return True
if self == FieldType.TEXT_SINGLE and to == FieldType.TEXT_PRIVATE:
return True
return False | python | def allow_upcast(self, to):
if self == to:
return True
if self == FieldType.TEXT_SINGLE and to == FieldType.TEXT_PRIVATE:
return True
return False | [
"def",
"allow_upcast",
"(",
"self",
",",
"to",
")",
":",
"if",
"self",
"==",
"to",
":",
"return",
"True",
"if",
"self",
"==",
"FieldType",
".",
"TEXT_SINGLE",
"and",
"to",
"==",
"FieldType",
".",
"TEXT_PRIVATE",
":",
"return",
"True",
"return",
"False"
] | Return true if the field type may be upcast to the other field type
`to`.
This relation specifies when it is safe to transfer data from this
field type to the given other field type `to`.
This is the case if any of the following holds true:
* `to` is equal to this type
* this type is :attr:`TEXT_SINGLE` and `to` is :attr:`TEXT_PRIVATE` | [
"Return",
"true",
"if",
"the",
"field",
"type",
"may",
"be",
"upcast",
"to",
"the",
"other",
"field",
"type",
"to",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/forms/xso.py#L252-L270 |
768 | horazont/aioxmpp | aioxmpp/forms/xso.py | Data.get_form_type | def get_form_type(self):
"""
Extract the ``FORM_TYPE`` from the fields.
:return: ``FORM_TYPE`` value or :data:`None`
:rtype: :class:`str` or :data:`None`
Return :data:`None` if no well-formed ``FORM_TYPE`` field is found in
the list of fields.
.. versionadded:: 0.8
"""
for field in self.fields:
if field.var == "FORM_TYPE" and field.type_ == FieldType.HIDDEN:
if len(field.values) != 1:
return None
return field.values[0] | python | def get_form_type(self):
for field in self.fields:
if field.var == "FORM_TYPE" and field.type_ == FieldType.HIDDEN:
if len(field.values) != 1:
return None
return field.values[0] | [
"def",
"get_form_type",
"(",
"self",
")",
":",
"for",
"field",
"in",
"self",
".",
"fields",
":",
"if",
"field",
".",
"var",
"==",
"\"FORM_TYPE\"",
"and",
"field",
".",
"type_",
"==",
"FieldType",
".",
"HIDDEN",
":",
"if",
"len",
"(",
"field",
".",
"values",
")",
"!=",
"1",
":",
"return",
"None",
"return",
"field",
".",
"values",
"[",
"0",
"]"
] | Extract the ``FORM_TYPE`` from the fields.
:return: ``FORM_TYPE`` value or :data:`None`
:rtype: :class:`str` or :data:`None`
Return :data:`None` if no well-formed ``FORM_TYPE`` field is found in
the list of fields.
.. versionadded:: 0.8 | [
"Extract",
"the",
"FORM_TYPE",
"from",
"the",
"fields",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/forms/xso.py#L623-L640 |
769 | horazont/aioxmpp | aioxmpp/ibr/service.py | get_registration_fields | def get_registration_fields(xmlstream,
timeout=60,
):
"""
A query is sent to the server to obtain the fields that need to be
filled to register with the server.
:param xmlstream: Specifies the stream connected to the server where
the account will be created.
:type xmlstream: :class:`aioxmpp.protocol.XMLStream`
:param timeout: Maximum time in seconds to wait for an IQ response, or
:data:`None` to disable the timeout.
:type timeout: :class:`~numbers.Real` or :data:`None`
:return: :attr:`list`
"""
iq = aioxmpp.IQ(
to=aioxmpp.JID.fromstr(xmlstream._to),
type_=aioxmpp.IQType.GET,
payload=xso.Query()
)
iq.autoset_id()
reply = yield from aioxmpp.protocol.send_and_wait_for(xmlstream,
[iq],
[aioxmpp.IQ],
timeout=timeout)
return reply.payload | python | def get_registration_fields(xmlstream,
timeout=60,
):
iq = aioxmpp.IQ(
to=aioxmpp.JID.fromstr(xmlstream._to),
type_=aioxmpp.IQType.GET,
payload=xso.Query()
)
iq.autoset_id()
reply = yield from aioxmpp.protocol.send_and_wait_for(xmlstream,
[iq],
[aioxmpp.IQ],
timeout=timeout)
return reply.payload | [
"def",
"get_registration_fields",
"(",
"xmlstream",
",",
"timeout",
"=",
"60",
",",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"to",
"=",
"aioxmpp",
".",
"JID",
".",
"fromstr",
"(",
"xmlstream",
".",
"_to",
")",
",",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"GET",
",",
"payload",
"=",
"xso",
".",
"Query",
"(",
")",
")",
"iq",
".",
"autoset_id",
"(",
")",
"reply",
"=",
"yield",
"from",
"aioxmpp",
".",
"protocol",
".",
"send_and_wait_for",
"(",
"xmlstream",
",",
"[",
"iq",
"]",
",",
"[",
"aioxmpp",
".",
"IQ",
"]",
",",
"timeout",
"=",
"timeout",
")",
"return",
"reply",
".",
"payload"
] | A query is sent to the server to obtain the fields that need to be
filled to register with the server.
:param xmlstream: Specifies the stream connected to the server where
the account will be created.
:type xmlstream: :class:`aioxmpp.protocol.XMLStream`
:param timeout: Maximum time in seconds to wait for an IQ response, or
:data:`None` to disable the timeout.
:type timeout: :class:`~numbers.Real` or :data:`None`
:return: :attr:`list` | [
"A",
"query",
"is",
"sent",
"to",
"the",
"server",
"to",
"obtain",
"the",
"fields",
"that",
"need",
"to",
"be",
"filled",
"to",
"register",
"with",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ibr/service.py#L34-L63 |
770 | horazont/aioxmpp | aioxmpp/ibr/service.py | register | def register(xmlstream,
query_xso,
timeout=60,
):
"""
Create a new account on the server.
:param query_xso: XSO with the information needed for the registration.
:type query_xso: :class:`~aioxmpp.ibr.Query`
:param xmlstream: Specifies the stream connected to the server where
the account will be created.
:type xmlstream: :class:`aioxmpp.protocol.XMLStream`
:param timeout: Maximum time in seconds to wait for an IQ response, or
:data:`None` to disable the timeout.
:type timeout: :class:`~numbers.Real` or :data:`None`
"""
iq = aioxmpp.IQ(
to=aioxmpp.JID.fromstr(xmlstream._to),
type_=aioxmpp.IQType.SET,
payload=query_xso
)
iq.autoset_id()
yield from aioxmpp.protocol.send_and_wait_for(xmlstream,
[iq],
[aioxmpp.IQ],
timeout=timeout) | python | def register(xmlstream,
query_xso,
timeout=60,
):
iq = aioxmpp.IQ(
to=aioxmpp.JID.fromstr(xmlstream._to),
type_=aioxmpp.IQType.SET,
payload=query_xso
)
iq.autoset_id()
yield from aioxmpp.protocol.send_and_wait_for(xmlstream,
[iq],
[aioxmpp.IQ],
timeout=timeout) | [
"def",
"register",
"(",
"xmlstream",
",",
"query_xso",
",",
"timeout",
"=",
"60",
",",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"to",
"=",
"aioxmpp",
".",
"JID",
".",
"fromstr",
"(",
"xmlstream",
".",
"_to",
")",
",",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"query_xso",
")",
"iq",
".",
"autoset_id",
"(",
")",
"yield",
"from",
"aioxmpp",
".",
"protocol",
".",
"send_and_wait_for",
"(",
"xmlstream",
",",
"[",
"iq",
"]",
",",
"[",
"aioxmpp",
".",
"IQ",
"]",
",",
"timeout",
"=",
"timeout",
")"
] | Create a new account on the server.
:param query_xso: XSO with the information needed for the registration.
:type query_xso: :class:`~aioxmpp.ibr.Query`
:param xmlstream: Specifies the stream connected to the server where
the account will be created.
:type xmlstream: :class:`aioxmpp.protocol.XMLStream`
:param timeout: Maximum time in seconds to wait for an IQ response, or
:data:`None` to disable the timeout.
:type timeout: :class:`~numbers.Real` or :data:`None` | [
"Create",
"a",
"new",
"account",
"on",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ibr/service.py#L67-L95 |
771 | horazont/aioxmpp | aioxmpp/ibr/service.py | get_used_fields | def get_used_fields(payload):
"""
Get a list containing the names of the fields that are used in the
xso.Query.
:param payload: Query object o be
:type payload: :class:`~aioxmpp.ibr.Query`
:return: :attr:`list`
"""
return [
tag
for tag, descriptor in payload.CHILD_MAP.items()
if descriptor.__get__(payload, type(payload)) is not None
] | python | def get_used_fields(payload):
return [
tag
for tag, descriptor in payload.CHILD_MAP.items()
if descriptor.__get__(payload, type(payload)) is not None
] | [
"def",
"get_used_fields",
"(",
"payload",
")",
":",
"return",
"[",
"tag",
"for",
"tag",
",",
"descriptor",
"in",
"payload",
".",
"CHILD_MAP",
".",
"items",
"(",
")",
"if",
"descriptor",
".",
"__get__",
"(",
"payload",
",",
"type",
"(",
"payload",
")",
")",
"is",
"not",
"None",
"]"
] | Get a list containing the names of the fields that are used in the
xso.Query.
:param payload: Query object o be
:type payload: :class:`~aioxmpp.ibr.Query`
:return: :attr:`list` | [
"Get",
"a",
"list",
"containing",
"the",
"names",
"of",
"the",
"fields",
"that",
"are",
"used",
"in",
"the",
"xso",
".",
"Query",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ibr/service.py#L98-L111 |
772 | horazont/aioxmpp | aioxmpp/ibr/service.py | RegistrationService.get_client_info | def get_client_info(self):
"""
A query is sent to the server to obtain the client's data stored at the
server.
:return: :class:`~aioxmpp.ibr.Query`
"""
iq = aioxmpp.IQ(
to=self.client.local_jid.bare().replace(localpart=None),
type_=aioxmpp.IQType.GET,
payload=xso.Query()
)
reply = (yield from self.client.send(iq))
return reply | python | def get_client_info(self):
iq = aioxmpp.IQ(
to=self.client.local_jid.bare().replace(localpart=None),
type_=aioxmpp.IQType.GET,
payload=xso.Query()
)
reply = (yield from self.client.send(iq))
return reply | [
"def",
"get_client_info",
"(",
"self",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"to",
"=",
"self",
".",
"client",
".",
"local_jid",
".",
"bare",
"(",
")",
".",
"replace",
"(",
"localpart",
"=",
"None",
")",
",",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"GET",
",",
"payload",
"=",
"xso",
".",
"Query",
"(",
")",
")",
"reply",
"=",
"(",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
")",
"return",
"reply"
] | A query is sent to the server to obtain the client's data stored at the
server.
:return: :class:`~aioxmpp.ibr.Query` | [
"A",
"query",
"is",
"sent",
"to",
"the",
"server",
"to",
"obtain",
"the",
"client",
"s",
"data",
"stored",
"at",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ibr/service.py#L132-L146 |
773 | horazont/aioxmpp | aioxmpp/ibr/service.py | RegistrationService.change_pass | def change_pass(self,
new_pass):
"""
Change the client password for 'new_pass'.
:param new_pass: New password of the client.
:type new_pass: :class:`str`
:param old_pass: Old password of the client.
:type old_pass: :class:`str`
"""
iq = aioxmpp.IQ(
to=self.client.local_jid.bare().replace(localpart=None),
type_=aioxmpp.IQType.SET,
payload=xso.Query(self.client.local_jid.localpart, new_pass)
)
yield from self.client.send(iq) | python | def change_pass(self,
new_pass):
iq = aioxmpp.IQ(
to=self.client.local_jid.bare().replace(localpart=None),
type_=aioxmpp.IQType.SET,
payload=xso.Query(self.client.local_jid.localpart, new_pass)
)
yield from self.client.send(iq) | [
"def",
"change_pass",
"(",
"self",
",",
"new_pass",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"to",
"=",
"self",
".",
"client",
".",
"local_jid",
".",
"bare",
"(",
")",
".",
"replace",
"(",
"localpart",
"=",
"None",
")",
",",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"xso",
".",
"Query",
"(",
"self",
".",
"client",
".",
"local_jid",
".",
"localpart",
",",
"new_pass",
")",
")",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")"
] | Change the client password for 'new_pass'.
:param new_pass: New password of the client.
:type new_pass: :class:`str`
:param old_pass: Old password of the client.
:type old_pass: :class:`str` | [
"Change",
"the",
"client",
"password",
"for",
"new_pass",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ibr/service.py#L149-L167 |
774 | horazont/aioxmpp | aioxmpp/ibr/service.py | RegistrationService.cancel_registration | def cancel_registration(self):
"""
Cancels the currents client's account with the server.
Even if the cancelation is succesful, this method will raise an
exception due to he account no longer exists for the server, so the
client will fail.
To continue with the execution, this method should be surrounded by a
try/except statement.
"""
iq = aioxmpp.IQ(
to=self.client.local_jid.bare().replace(localpart=None),
type_=aioxmpp.IQType.SET,
payload=xso.Query()
)
iq.payload.remove = True
yield from self.client.send(iq) | python | def cancel_registration(self):
iq = aioxmpp.IQ(
to=self.client.local_jid.bare().replace(localpart=None),
type_=aioxmpp.IQType.SET,
payload=xso.Query()
)
iq.payload.remove = True
yield from self.client.send(iq) | [
"def",
"cancel_registration",
"(",
"self",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"to",
"=",
"self",
".",
"client",
".",
"local_jid",
".",
"bare",
"(",
")",
".",
"replace",
"(",
"localpart",
"=",
"None",
")",
",",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"xso",
".",
"Query",
"(",
")",
")",
"iq",
".",
"payload",
".",
"remove",
"=",
"True",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")"
] | Cancels the currents client's account with the server.
Even if the cancelation is succesful, this method will raise an
exception due to he account no longer exists for the server, so the
client will fail.
To continue with the execution, this method should be surrounded by a
try/except statement. | [
"Cancels",
"the",
"currents",
"client",
"s",
"account",
"with",
"the",
"server",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ibr/service.py#L170-L187 |
775 | horazont/aioxmpp | aioxmpp/node.py | discover_connectors | def discover_connectors(
domain: str,
loop=None,
logger=logger):
"""
Discover all connection options for a domain, in descending order of
preference.
This coroutine returns options discovered from SRV records, or if none are
found, the generic option using the domain name and the default XMPP client
port.
Each option is represented by a triple ``(host, port, connector)``.
`connector` is a :class:`aioxmpp.connector.BaseConnector` instance which is
suitable to connect to the given host and port.
`logger` is the logger used by the function.
The following sources are supported:
* :rfc:`6120` SRV records. One option is returned per SRV record.
If one of the SRV records points to the root name (``.``),
:class:`ValueError` is raised (the domain specifically said that XMPP is
not supported here).
* :xep:`368` SRV records. One option is returned per SRV record.
* :rfc:`6120` fallback process (only if no SRV records are found). One
option is returned for the host name with the default XMPP client port.
The options discovered from SRV records are mixed together, ordered by
priority and then within priorities are shuffled according to their weight.
Thus, if there are multiple records of equal priority, the result of the
function is not deterministic.
.. versionadded:: 0.6
"""
domain_encoded = domain.encode("idna") + b"."
starttls_srv_failed = False
tls_srv_failed = False
try:
starttls_srv_records = yield from network.lookup_srv(
domain_encoded,
"xmpp-client",
)
starttls_srv_disabled = False
except dns.resolver.NoNameservers as exc:
starttls_srv_records = []
starttls_srv_disabled = False
starttls_srv_failed = True
starttls_srv_exc = exc
logger.debug("xmpp-client SRV lookup for domain %s failed "
"(may not be fatal)",
domain_encoded,
exc_info=True)
except ValueError:
starttls_srv_records = []
starttls_srv_disabled = True
try:
tls_srv_records = yield from network.lookup_srv(
domain_encoded,
"xmpps-client",
)
tls_srv_disabled = False
except dns.resolver.NoNameservers:
tls_srv_records = []
tls_srv_disabled = False
tls_srv_failed = True
logger.debug("xmpps-client SRV lookup for domain %s failed "
"(may not be fatal)",
domain_encoded,
exc_info=True)
except ValueError:
tls_srv_records = []
tls_srv_disabled = True
if starttls_srv_failed and (tls_srv_failed or tls_srv_records is None):
# the failure is probably more useful as a diagnostic
# if we find a good reason to allow this scenario, we might change it
# later.
raise starttls_srv_exc
if starttls_srv_disabled and (tls_srv_disabled or tls_srv_records is None):
raise ValueError(
"XMPP not enabled on domain {!r}".format(domain),
)
if starttls_srv_records is None and tls_srv_records is None:
# no SRV records published, fall back
logger.debug(
"no SRV records found for %s, falling back",
domain,
)
return [
(domain, 5222, connector.STARTTLSConnector()),
]
starttls_srv_records = starttls_srv_records or []
tls_srv_records = tls_srv_records or []
srv_records = [
(prio, weight, (host.decode("ascii"), port,
connector.STARTTLSConnector()))
for prio, weight, (host, port) in starttls_srv_records
]
srv_records.extend(
(prio, weight, (host.decode("ascii"), port,
connector.XMPPOverTLSConnector()))
for prio, weight, (host, port) in tls_srv_records
)
options = list(
network.group_and_order_srv_records(srv_records)
)
logger.debug(
"options for %s: %r",
domain,
options,
)
return options | python | def discover_connectors(
domain: str,
loop=None,
logger=logger):
domain_encoded = domain.encode("idna") + b"."
starttls_srv_failed = False
tls_srv_failed = False
try:
starttls_srv_records = yield from network.lookup_srv(
domain_encoded,
"xmpp-client",
)
starttls_srv_disabled = False
except dns.resolver.NoNameservers as exc:
starttls_srv_records = []
starttls_srv_disabled = False
starttls_srv_failed = True
starttls_srv_exc = exc
logger.debug("xmpp-client SRV lookup for domain %s failed "
"(may not be fatal)",
domain_encoded,
exc_info=True)
except ValueError:
starttls_srv_records = []
starttls_srv_disabled = True
try:
tls_srv_records = yield from network.lookup_srv(
domain_encoded,
"xmpps-client",
)
tls_srv_disabled = False
except dns.resolver.NoNameservers:
tls_srv_records = []
tls_srv_disabled = False
tls_srv_failed = True
logger.debug("xmpps-client SRV lookup for domain %s failed "
"(may not be fatal)",
domain_encoded,
exc_info=True)
except ValueError:
tls_srv_records = []
tls_srv_disabled = True
if starttls_srv_failed and (tls_srv_failed or tls_srv_records is None):
# the failure is probably more useful as a diagnostic
# if we find a good reason to allow this scenario, we might change it
# later.
raise starttls_srv_exc
if starttls_srv_disabled and (tls_srv_disabled or tls_srv_records is None):
raise ValueError(
"XMPP not enabled on domain {!r}".format(domain),
)
if starttls_srv_records is None and tls_srv_records is None:
# no SRV records published, fall back
logger.debug(
"no SRV records found for %s, falling back",
domain,
)
return [
(domain, 5222, connector.STARTTLSConnector()),
]
starttls_srv_records = starttls_srv_records or []
tls_srv_records = tls_srv_records or []
srv_records = [
(prio, weight, (host.decode("ascii"), port,
connector.STARTTLSConnector()))
for prio, weight, (host, port) in starttls_srv_records
]
srv_records.extend(
(prio, weight, (host.decode("ascii"), port,
connector.XMPPOverTLSConnector()))
for prio, weight, (host, port) in tls_srv_records
)
options = list(
network.group_and_order_srv_records(srv_records)
)
logger.debug(
"options for %s: %r",
domain,
options,
)
return options | [
"def",
"discover_connectors",
"(",
"domain",
":",
"str",
",",
"loop",
"=",
"None",
",",
"logger",
"=",
"logger",
")",
":",
"domain_encoded",
"=",
"domain",
".",
"encode",
"(",
"\"idna\"",
")",
"+",
"b\".\"",
"starttls_srv_failed",
"=",
"False",
"tls_srv_failed",
"=",
"False",
"try",
":",
"starttls_srv_records",
"=",
"yield",
"from",
"network",
".",
"lookup_srv",
"(",
"domain_encoded",
",",
"\"xmpp-client\"",
",",
")",
"starttls_srv_disabled",
"=",
"False",
"except",
"dns",
".",
"resolver",
".",
"NoNameservers",
"as",
"exc",
":",
"starttls_srv_records",
"=",
"[",
"]",
"starttls_srv_disabled",
"=",
"False",
"starttls_srv_failed",
"=",
"True",
"starttls_srv_exc",
"=",
"exc",
"logger",
".",
"debug",
"(",
"\"xmpp-client SRV lookup for domain %s failed \"",
"\"(may not be fatal)\"",
",",
"domain_encoded",
",",
"exc_info",
"=",
"True",
")",
"except",
"ValueError",
":",
"starttls_srv_records",
"=",
"[",
"]",
"starttls_srv_disabled",
"=",
"True",
"try",
":",
"tls_srv_records",
"=",
"yield",
"from",
"network",
".",
"lookup_srv",
"(",
"domain_encoded",
",",
"\"xmpps-client\"",
",",
")",
"tls_srv_disabled",
"=",
"False",
"except",
"dns",
".",
"resolver",
".",
"NoNameservers",
":",
"tls_srv_records",
"=",
"[",
"]",
"tls_srv_disabled",
"=",
"False",
"tls_srv_failed",
"=",
"True",
"logger",
".",
"debug",
"(",
"\"xmpps-client SRV lookup for domain %s failed \"",
"\"(may not be fatal)\"",
",",
"domain_encoded",
",",
"exc_info",
"=",
"True",
")",
"except",
"ValueError",
":",
"tls_srv_records",
"=",
"[",
"]",
"tls_srv_disabled",
"=",
"True",
"if",
"starttls_srv_failed",
"and",
"(",
"tls_srv_failed",
"or",
"tls_srv_records",
"is",
"None",
")",
":",
"# the failure is probably more useful as a diagnostic",
"# if we find a good reason to allow this scenario, we might change it",
"# later.",
"raise",
"starttls_srv_exc",
"if",
"starttls_srv_disabled",
"and",
"(",
"tls_srv_disabled",
"or",
"tls_srv_records",
"is",
"None",
")",
":",
"raise",
"ValueError",
"(",
"\"XMPP not enabled on domain {!r}\"",
".",
"format",
"(",
"domain",
")",
",",
")",
"if",
"starttls_srv_records",
"is",
"None",
"and",
"tls_srv_records",
"is",
"None",
":",
"# no SRV records published, fall back",
"logger",
".",
"debug",
"(",
"\"no SRV records found for %s, falling back\"",
",",
"domain",
",",
")",
"return",
"[",
"(",
"domain",
",",
"5222",
",",
"connector",
".",
"STARTTLSConnector",
"(",
")",
")",
",",
"]",
"starttls_srv_records",
"=",
"starttls_srv_records",
"or",
"[",
"]",
"tls_srv_records",
"=",
"tls_srv_records",
"or",
"[",
"]",
"srv_records",
"=",
"[",
"(",
"prio",
",",
"weight",
",",
"(",
"host",
".",
"decode",
"(",
"\"ascii\"",
")",
",",
"port",
",",
"connector",
".",
"STARTTLSConnector",
"(",
")",
")",
")",
"for",
"prio",
",",
"weight",
",",
"(",
"host",
",",
"port",
")",
"in",
"starttls_srv_records",
"]",
"srv_records",
".",
"extend",
"(",
"(",
"prio",
",",
"weight",
",",
"(",
"host",
".",
"decode",
"(",
"\"ascii\"",
")",
",",
"port",
",",
"connector",
".",
"XMPPOverTLSConnector",
"(",
")",
")",
")",
"for",
"prio",
",",
"weight",
",",
"(",
"host",
",",
"port",
")",
"in",
"tls_srv_records",
")",
"options",
"=",
"list",
"(",
"network",
".",
"group_and_order_srv_records",
"(",
"srv_records",
")",
")",
"logger",
".",
"debug",
"(",
"\"options for %s: %r\"",
",",
"domain",
",",
"options",
",",
")",
"return",
"options"
] | Discover all connection options for a domain, in descending order of
preference.
This coroutine returns options discovered from SRV records, or if none are
found, the generic option using the domain name and the default XMPP client
port.
Each option is represented by a triple ``(host, port, connector)``.
`connector` is a :class:`aioxmpp.connector.BaseConnector` instance which is
suitable to connect to the given host and port.
`logger` is the logger used by the function.
The following sources are supported:
* :rfc:`6120` SRV records. One option is returned per SRV record.
If one of the SRV records points to the root name (``.``),
:class:`ValueError` is raised (the domain specifically said that XMPP is
not supported here).
* :xep:`368` SRV records. One option is returned per SRV record.
* :rfc:`6120` fallback process (only if no SRV records are found). One
option is returned for the host name with the default XMPP client port.
The options discovered from SRV records are mixed together, ordered by
priority and then within priorities are shuffled according to their weight.
Thus, if there are multiple records of equal priority, the result of the
function is not deterministic.
.. versionadded:: 0.6 | [
"Discover",
"all",
"connection",
"options",
"for",
"a",
"domain",
"in",
"descending",
"order",
"of",
"preference",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/node.py#L105-L231 |
776 | horazont/aioxmpp | aioxmpp/node.py | Client.stop | def stop(self):
"""
Stop the client. This sends a signal to the clients main task which
makes it terminate.
It may take some cycles through the event loop to stop the client
task. To check whether the task has actually stopped, query
:attr:`running`.
"""
if not self.running:
return
self.logger.debug("stopping main task of %r", self, stack_info=True)
self._main_task.cancel() | python | def stop(self):
if not self.running:
return
self.logger.debug("stopping main task of %r", self, stack_info=True)
self._main_task.cancel() | [
"def",
"stop",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"running",
":",
"return",
"self",
".",
"logger",
".",
"debug",
"(",
"\"stopping main task of %r\"",
",",
"self",
",",
"stack_info",
"=",
"True",
")",
"self",
".",
"_main_task",
".",
"cancel",
"(",
")"
] | Stop the client. This sends a signal to the clients main task which
makes it terminate.
It may take some cycles through the event loop to stop the client
task. To check whether the task has actually stopped, query
:attr:`running`. | [
"Stop",
"the",
"client",
".",
"This",
"sends",
"a",
"signal",
"to",
"the",
"clients",
"main",
"task",
"which",
"makes",
"it",
"terminate",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/node.py#L1058-L1071 |
777 | horazont/aioxmpp | aioxmpp/node.py | Client.enqueue | def enqueue(self, stanza, **kwargs):
"""
Put a `stanza` in the internal transmission queue and return a token to
track it.
:param stanza: Stanza to send
:type stanza: :class:`IQ`, :class:`Message` or :class:`Presence`
:param kwargs: see :class:`StanzaToken`
:raises ConnectionError: if the stream is not :attr:`established`
yet.
:return: token which tracks the stanza
:rtype: :class:`StanzaToken`
The `stanza` is enqueued in the active queue for transmission and will
be sent on the next opportunity. The relative ordering of stanzas
enqueued is always preserved.
Return a fresh :class:`StanzaToken` instance which traks the progress
of the transmission of the `stanza`. The `kwargs` are forwarded to the
:class:`StanzaToken` constructor.
This method calls :meth:`~.stanza.StanzaBase.autoset_id` on the stanza
automatically.
.. seealso::
:meth:`send`
for a more high-level way to send stanzas.
.. versionchanged:: 0.10
This method has been moved from
:meth:`aioxmpp.stream.StanzaStream.enqueue`.
"""
if not self.established_event.is_set():
raise ConnectionError("stream is not ready")
return self.stream._enqueue(stanza, **kwargs) | python | def enqueue(self, stanza, **kwargs):
if not self.established_event.is_set():
raise ConnectionError("stream is not ready")
return self.stream._enqueue(stanza, **kwargs) | [
"def",
"enqueue",
"(",
"self",
",",
"stanza",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"self",
".",
"established_event",
".",
"is_set",
"(",
")",
":",
"raise",
"ConnectionError",
"(",
"\"stream is not ready\"",
")",
"return",
"self",
".",
"stream",
".",
"_enqueue",
"(",
"stanza",
",",
"*",
"*",
"kwargs",
")"
] | Put a `stanza` in the internal transmission queue and return a token to
track it.
:param stanza: Stanza to send
:type stanza: :class:`IQ`, :class:`Message` or :class:`Presence`
:param kwargs: see :class:`StanzaToken`
:raises ConnectionError: if the stream is not :attr:`established`
yet.
:return: token which tracks the stanza
:rtype: :class:`StanzaToken`
The `stanza` is enqueued in the active queue for transmission and will
be sent on the next opportunity. The relative ordering of stanzas
enqueued is always preserved.
Return a fresh :class:`StanzaToken` instance which traks the progress
of the transmission of the `stanza`. The `kwargs` are forwarded to the
:class:`StanzaToken` constructor.
This method calls :meth:`~.stanza.StanzaBase.autoset_id` on the stanza
automatically.
.. seealso::
:meth:`send`
for a more high-level way to send stanzas.
.. versionchanged:: 0.10
This method has been moved from
:meth:`aioxmpp.stream.StanzaStream.enqueue`. | [
"Put",
"a",
"stanza",
"in",
"the",
"internal",
"transmission",
"queue",
"and",
"return",
"a",
"token",
"to",
"track",
"it",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/node.py#L1215-L1252 |
778 | horazont/aioxmpp | aioxmpp/node.py | Client.send | def send(self, stanza, *, timeout=None, cb=None):
"""
Send a stanza.
:param stanza: Stanza to send
:type stanza: :class:`~.IQ`, :class:`~.Presence` or :class:`~.Message`
:param timeout: Maximum time in seconds to wait for an IQ response, or
:data:`None` to disable the timeout.
:type timeout: :class:`~numbers.Real` or :data:`None`
:param cb: Optional callback which is called synchronously when the
reply is received (IQ requests only!)
:raise OSError: if the underlying XML stream fails and stream
management is not disabled.
:raise aioxmpp.stream.DestructionRequested:
if the stream is closed while sending the stanza or waiting for a
response.
:raise aioxmpp.errors.XMPPError: if an error IQ response is received
:raise aioxmpp.errors.ErroneousStanza: if the IQ response could not be
parsed
:raise ValueError: if `cb` is given and `stanza` is not an IQ request.
:return: IQ response :attr:`~.IQ.payload` or :data:`None`
Send the stanza and wait for it to be sent. If the stanza is an IQ
request, the response is awaited and the :attr:`~.IQ.payload` of the
response is returned.
If the stream is currently not ready, this method blocks until the
stream is ready to send payload stanzas. Note that this may be before
initial presence has been sent. To synchronise with that type of
events, use the appropriate signals.
The `timeout` as well as any of the exception cases referring to a
"response" do not apply for IQ response stanzas, message stanzas or
presence stanzas sent with this method, as this method only waits for
a reply if an IQ *request* stanza is being sent.
If `stanza` is an IQ request and the response is not received within
`timeout` seconds, :class:`TimeoutError` (not
:class:`asyncio.TimeoutError`!) is raised.
If `cb` is given, `stanza` must be an IQ request (otherwise,
:class:`ValueError` is raised before the stanza is sent). It must be a
callable returning an awaitable. It receives the response stanza as
first and only argument. The returned awaitable is awaited by
:meth:`send` and the result is returned instead of the original
payload. `cb` is called synchronously from the stream handling loop
when the response is received, so it can benefit from the strong
ordering guarantees given by XMPP XML Streams.
The `cb` may also return :data:`None`, in which case :meth:`send` will
simply return the IQ payload as if `cb` was not given. Since the return
value of coroutine functions is awaitable, it is valid and supported to
pass a coroutine function as `cb`.
.. warning::
Remember that it is an implementation detail of the event loop when
a coroutine is scheduled after it awaited an awaitable; this
implies that if the caller of :meth:`send` is merely awaiting the
:meth:`send` coroutine, the strong ordering guarantees of XMPP XML
Streams are lost.
To regain those, use the `cb` argument.
.. note::
For the sake of readability, unless you really need the strong
ordering guarantees, avoid the use of the `cb` argument. Avoid
using a coroutine function unless you really need to.
.. versionchanged:: 0.10
* This method now waits until the stream is ready to send stanza¸
payloads.
* This method was moved from
:meth:`aioxmpp.stream.StanzaStream.send`.
.. versionchanged:: 0.9
The `cb` argument was added.
.. versionadded:: 0.8
"""
if not self.running:
raise ConnectionError("client is not running")
if not self.established:
self.logger.debug("send(%s): stream not established, waiting",
stanza)
# wait for the stream to be established
stopped_fut = self.on_stopped.future()
failure_fut = self.on_failure.future()
established_fut = asyncio.ensure_future(
self.established_event.wait()
)
done, pending = yield from asyncio.wait(
[
established_fut,
failure_fut,
stopped_fut,
],
return_when=asyncio.FIRST_COMPLETED,
)
if not established_fut.done():
established_fut.cancel()
if failure_fut.done():
if not stopped_fut.done():
stopped_fut.cancel()
failure_fut.exception()
raise ConnectionError("client failed to connect")
if stopped_fut.done():
raise ConnectionError("client shut down by user request")
self.logger.debug("send(%s): stream established, sending")
return (yield from self.stream._send_immediately(stanza,
timeout=timeout,
cb=cb)) | python | def send(self, stanza, *, timeout=None, cb=None):
if not self.running:
raise ConnectionError("client is not running")
if not self.established:
self.logger.debug("send(%s): stream not established, waiting",
stanza)
# wait for the stream to be established
stopped_fut = self.on_stopped.future()
failure_fut = self.on_failure.future()
established_fut = asyncio.ensure_future(
self.established_event.wait()
)
done, pending = yield from asyncio.wait(
[
established_fut,
failure_fut,
stopped_fut,
],
return_when=asyncio.FIRST_COMPLETED,
)
if not established_fut.done():
established_fut.cancel()
if failure_fut.done():
if not stopped_fut.done():
stopped_fut.cancel()
failure_fut.exception()
raise ConnectionError("client failed to connect")
if stopped_fut.done():
raise ConnectionError("client shut down by user request")
self.logger.debug("send(%s): stream established, sending")
return (yield from self.stream._send_immediately(stanza,
timeout=timeout,
cb=cb)) | [
"def",
"send",
"(",
"self",
",",
"stanza",
",",
"*",
",",
"timeout",
"=",
"None",
",",
"cb",
"=",
"None",
")",
":",
"if",
"not",
"self",
".",
"running",
":",
"raise",
"ConnectionError",
"(",
"\"client is not running\"",
")",
"if",
"not",
"self",
".",
"established",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"send(%s): stream not established, waiting\"",
",",
"stanza",
")",
"# wait for the stream to be established",
"stopped_fut",
"=",
"self",
".",
"on_stopped",
".",
"future",
"(",
")",
"failure_fut",
"=",
"self",
".",
"on_failure",
".",
"future",
"(",
")",
"established_fut",
"=",
"asyncio",
".",
"ensure_future",
"(",
"self",
".",
"established_event",
".",
"wait",
"(",
")",
")",
"done",
",",
"pending",
"=",
"yield",
"from",
"asyncio",
".",
"wait",
"(",
"[",
"established_fut",
",",
"failure_fut",
",",
"stopped_fut",
",",
"]",
",",
"return_when",
"=",
"asyncio",
".",
"FIRST_COMPLETED",
",",
")",
"if",
"not",
"established_fut",
".",
"done",
"(",
")",
":",
"established_fut",
".",
"cancel",
"(",
")",
"if",
"failure_fut",
".",
"done",
"(",
")",
":",
"if",
"not",
"stopped_fut",
".",
"done",
"(",
")",
":",
"stopped_fut",
".",
"cancel",
"(",
")",
"failure_fut",
".",
"exception",
"(",
")",
"raise",
"ConnectionError",
"(",
"\"client failed to connect\"",
")",
"if",
"stopped_fut",
".",
"done",
"(",
")",
":",
"raise",
"ConnectionError",
"(",
"\"client shut down by user request\"",
")",
"self",
".",
"logger",
".",
"debug",
"(",
"\"send(%s): stream established, sending\"",
")",
"return",
"(",
"yield",
"from",
"self",
".",
"stream",
".",
"_send_immediately",
"(",
"stanza",
",",
"timeout",
"=",
"timeout",
",",
"cb",
"=",
"cb",
")",
")"
] | Send a stanza.
:param stanza: Stanza to send
:type stanza: :class:`~.IQ`, :class:`~.Presence` or :class:`~.Message`
:param timeout: Maximum time in seconds to wait for an IQ response, or
:data:`None` to disable the timeout.
:type timeout: :class:`~numbers.Real` or :data:`None`
:param cb: Optional callback which is called synchronously when the
reply is received (IQ requests only!)
:raise OSError: if the underlying XML stream fails and stream
management is not disabled.
:raise aioxmpp.stream.DestructionRequested:
if the stream is closed while sending the stanza or waiting for a
response.
:raise aioxmpp.errors.XMPPError: if an error IQ response is received
:raise aioxmpp.errors.ErroneousStanza: if the IQ response could not be
parsed
:raise ValueError: if `cb` is given and `stanza` is not an IQ request.
:return: IQ response :attr:`~.IQ.payload` or :data:`None`
Send the stanza and wait for it to be sent. If the stanza is an IQ
request, the response is awaited and the :attr:`~.IQ.payload` of the
response is returned.
If the stream is currently not ready, this method blocks until the
stream is ready to send payload stanzas. Note that this may be before
initial presence has been sent. To synchronise with that type of
events, use the appropriate signals.
The `timeout` as well as any of the exception cases referring to a
"response" do not apply for IQ response stanzas, message stanzas or
presence stanzas sent with this method, as this method only waits for
a reply if an IQ *request* stanza is being sent.
If `stanza` is an IQ request and the response is not received within
`timeout` seconds, :class:`TimeoutError` (not
:class:`asyncio.TimeoutError`!) is raised.
If `cb` is given, `stanza` must be an IQ request (otherwise,
:class:`ValueError` is raised before the stanza is sent). It must be a
callable returning an awaitable. It receives the response stanza as
first and only argument. The returned awaitable is awaited by
:meth:`send` and the result is returned instead of the original
payload. `cb` is called synchronously from the stream handling loop
when the response is received, so it can benefit from the strong
ordering guarantees given by XMPP XML Streams.
The `cb` may also return :data:`None`, in which case :meth:`send` will
simply return the IQ payload as if `cb` was not given. Since the return
value of coroutine functions is awaitable, it is valid and supported to
pass a coroutine function as `cb`.
.. warning::
Remember that it is an implementation detail of the event loop when
a coroutine is scheduled after it awaited an awaitable; this
implies that if the caller of :meth:`send` is merely awaiting the
:meth:`send` coroutine, the strong ordering guarantees of XMPP XML
Streams are lost.
To regain those, use the `cb` argument.
.. note::
For the sake of readability, unless you really need the strong
ordering guarantees, avoid the use of the `cb` argument. Avoid
using a coroutine function unless you really need to.
.. versionchanged:: 0.10
* This method now waits until the stream is ready to send stanza¸
payloads.
* This method was moved from
:meth:`aioxmpp.stream.StanzaStream.send`.
.. versionchanged:: 0.9
The `cb` argument was added.
.. versionadded:: 0.8 | [
"Send",
"a",
"stanza",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/node.py#L1255-L1372 |
779 | horazont/aioxmpp | aioxmpp/ping/service.py | ping | def ping(client, peer):
"""
Ping a peer.
:param peer: The peer to ping.
:type peer: :class:`aioxmpp.JID`
:raises aioxmpp.errors.XMPPError: as received
Send a :xep:`199` ping IQ to `peer` and wait for the reply.
This is a low-level version of :meth:`aioxmpp.PingService.ping`.
**When to use this function vs. the service method:** See
:meth:`aioxmpp.PingService.ping`.
.. note::
If the peer does not support :xep:`199`, they will respond with
a ``cancel`` ``service-unavailable`` error. However, some
implementations return a ``cancel`` ``feature-not-implemented``
error instead. Callers should be prepared for the
:class:`aioxmpp.XMPPCancelError` exceptions in those cases.
.. versionchanged:: 0.11
Extracted this helper from :class:`aioxmpp.PingService`.
"""
iq = aioxmpp.IQ(
to=peer,
type_=aioxmpp.IQType.GET,
payload=ping_xso.Ping()
)
yield from client.send(iq) | python | def ping(client, peer):
iq = aioxmpp.IQ(
to=peer,
type_=aioxmpp.IQType.GET,
payload=ping_xso.Ping()
)
yield from client.send(iq) | [
"def",
"ping",
"(",
"client",
",",
"peer",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"to",
"=",
"peer",
",",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"GET",
",",
"payload",
"=",
"ping_xso",
".",
"Ping",
"(",
")",
")",
"yield",
"from",
"client",
".",
"send",
"(",
"iq",
")"
] | Ping a peer.
:param peer: The peer to ping.
:type peer: :class:`aioxmpp.JID`
:raises aioxmpp.errors.XMPPError: as received
Send a :xep:`199` ping IQ to `peer` and wait for the reply.
This is a low-level version of :meth:`aioxmpp.PingService.ping`.
**When to use this function vs. the service method:** See
:meth:`aioxmpp.PingService.ping`.
.. note::
If the peer does not support :xep:`199`, they will respond with
a ``cancel`` ``service-unavailable`` error. However, some
implementations return a ``cancel`` ``feature-not-implemented``
error instead. Callers should be prepared for the
:class:`aioxmpp.XMPPCancelError` exceptions in those cases.
.. versionchanged:: 0.11
Extracted this helper from :class:`aioxmpp.PingService`. | [
"Ping",
"a",
"peer",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/ping/service.py#L90-L124 |
780 | horazont/aioxmpp | aioxmpp/shim/service.py | SHIMService.register_header | def register_header(self, name):
"""
Register support for the SHIM header with the given `name`.
If the header has already been registered as supported,
:class:`ValueError` is raised.
"""
self._node.register_feature(
"#".join([namespaces.xep0131_shim, name])
) | python | def register_header(self, name):
self._node.register_feature(
"#".join([namespaces.xep0131_shim, name])
) | [
"def",
"register_header",
"(",
"self",
",",
"name",
")",
":",
"self",
".",
"_node",
".",
"register_feature",
"(",
"\"#\"",
".",
"join",
"(",
"[",
"namespaces",
".",
"xep0131_shim",
",",
"name",
"]",
")",
")"
] | Register support for the SHIM header with the given `name`.
If the header has already been registered as supported,
:class:`ValueError` is raised. | [
"Register",
"support",
"for",
"the",
"SHIM",
"header",
"with",
"the",
"given",
"name",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/shim/service.py#L71-L81 |
781 | horazont/aioxmpp | aioxmpp/shim/service.py | SHIMService.unregister_header | def unregister_header(self, name):
"""
Unregister support for the SHIM header with the given `name`.
If the header is currently not registered as supported,
:class:`KeyError` is raised.
"""
self._node.unregister_feature(
"#".join([namespaces.xep0131_shim, name])
) | python | def unregister_header(self, name):
self._node.unregister_feature(
"#".join([namespaces.xep0131_shim, name])
) | [
"def",
"unregister_header",
"(",
"self",
",",
"name",
")",
":",
"self",
".",
"_node",
".",
"unregister_feature",
"(",
"\"#\"",
".",
"join",
"(",
"[",
"namespaces",
".",
"xep0131_shim",
",",
"name",
"]",
")",
")"
] | Unregister support for the SHIM header with the given `name`.
If the header is currently not registered as supported,
:class:`KeyError` is raised. | [
"Unregister",
"support",
"for",
"the",
"SHIM",
"header",
"with",
"the",
"given",
"name",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/shim/service.py#L83-L93 |
782 | horazont/aioxmpp | aioxmpp/vcard/service.py | VCardService.set_vcard | def set_vcard(self, vcard):
"""
Store the vCard `vcard` for the connected entity.
:param vcard: the vCard to store.
.. note::
`vcard` should always be derived from the result of
`get_vcard` to preserve the elements of the vcard the
client does not modify.
.. warning::
It is in the responsibility of the user to supply valid
vcard data as per :xep:`0054`.
"""
iq = aioxmpp.IQ(
type_=aioxmpp.IQType.SET,
payload=vcard,
)
yield from self.client.send(iq) | python | def set_vcard(self, vcard):
iq = aioxmpp.IQ(
type_=aioxmpp.IQType.SET,
payload=vcard,
)
yield from self.client.send(iq) | [
"def",
"set_vcard",
"(",
"self",
",",
"vcard",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"IQ",
"(",
"type_",
"=",
"aioxmpp",
".",
"IQType",
".",
"SET",
",",
"payload",
"=",
"vcard",
",",
")",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")"
] | Store the vCard `vcard` for the connected entity.
:param vcard: the vCard to store.
.. note::
`vcard` should always be derived from the result of
`get_vcard` to preserve the elements of the vcard the
client does not modify.
.. warning::
It is in the responsibility of the user to supply valid
vcard data as per :xep:`0054`. | [
"Store",
"the",
"vCard",
"vcard",
"for",
"the",
"connected",
"entity",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/vcard/service.py#L71-L92 |
783 | horazont/aioxmpp | aioxmpp/chatstates/utils.py | ChatStateManager.handle | def handle(self, state, message=False):
"""
Handle a state update.
:param state: the new chat state
:type state: :class:`~aioxmpp.chatstates.ChatState`
:param message: pass true to indicate that we handle the
:data:`ACTIVE` state that is implied by
sending a content message.
:type message: :class:`bool`
:returns: whether a standalone notification must be sent for
this state update, respective if a chat state
notification must be included with the message.
:raises ValueError: if `message` is true and a state other
than :data:`ACTIVE` is passed.
"""
if message:
if state != chatstates_xso.ChatState.ACTIVE:
raise ValueError(
"Only the state ACTIVE can be sent with messages."
)
elif self._state == state:
return False
self._state = state
return self._strategy.sending | python | def handle(self, state, message=False):
if message:
if state != chatstates_xso.ChatState.ACTIVE:
raise ValueError(
"Only the state ACTIVE can be sent with messages."
)
elif self._state == state:
return False
self._state = state
return self._strategy.sending | [
"def",
"handle",
"(",
"self",
",",
"state",
",",
"message",
"=",
"False",
")",
":",
"if",
"message",
":",
"if",
"state",
"!=",
"chatstates_xso",
".",
"ChatState",
".",
"ACTIVE",
":",
"raise",
"ValueError",
"(",
"\"Only the state ACTIVE can be sent with messages.\"",
")",
"elif",
"self",
".",
"_state",
"==",
"state",
":",
"return",
"False",
"self",
".",
"_state",
"=",
"state",
"return",
"self",
".",
"_strategy",
".",
"sending"
] | Handle a state update.
:param state: the new chat state
:type state: :class:`~aioxmpp.chatstates.ChatState`
:param message: pass true to indicate that we handle the
:data:`ACTIVE` state that is implied by
sending a content message.
:type message: :class:`bool`
:returns: whether a standalone notification must be sent for
this state update, respective if a chat state
notification must be included with the message.
:raises ValueError: if `message` is true and a state other
than :data:`ACTIVE` is passed. | [
"Handle",
"a",
"state",
"update",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/chatstates/utils.py#L111-L139 |
784 | horazont/aioxmpp | aioxmpp/protocol.py | XMLStream.close | def close(self):
"""
Close the XML stream and the underlying transport.
This gracefully shuts down the XML stream and the transport, if
possible by writing the eof using :meth:`asyncio.Transport.write_eof`
after sending the stream footer.
After a call to :meth:`close`, no other stream manipulating or sending
method can be called; doing so will result in a
:class:`ConnectionError` exception or any exception caused by the
transport during shutdown.
Calling :meth:`close` while the stream is closing or closed is a
no-op.
"""
if (self._smachine.state == State.CLOSING or
self._smachine.state == State.CLOSED):
return
self._writer.close()
if self._transport.can_write_eof():
self._transport.write_eof()
if self._smachine.state == State.STREAM_HEADER_SENT:
# at this point, we cannot wait for the peer to send
# </stream:stream>
self._close_transport()
self._smachine.state = State.CLOSING | python | def close(self):
if (self._smachine.state == State.CLOSING or
self._smachine.state == State.CLOSED):
return
self._writer.close()
if self._transport.can_write_eof():
self._transport.write_eof()
if self._smachine.state == State.STREAM_HEADER_SENT:
# at this point, we cannot wait for the peer to send
# </stream:stream>
self._close_transport()
self._smachine.state = State.CLOSING | [
"def",
"close",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_smachine",
".",
"state",
"==",
"State",
".",
"CLOSING",
"or",
"self",
".",
"_smachine",
".",
"state",
"==",
"State",
".",
"CLOSED",
")",
":",
"return",
"self",
".",
"_writer",
".",
"close",
"(",
")",
"if",
"self",
".",
"_transport",
".",
"can_write_eof",
"(",
")",
":",
"self",
".",
"_transport",
".",
"write_eof",
"(",
")",
"if",
"self",
".",
"_smachine",
".",
"state",
"==",
"State",
".",
"STREAM_HEADER_SENT",
":",
"# at this point, we cannot wait for the peer to send",
"# </stream:stream>",
"self",
".",
"_close_transport",
"(",
")",
"self",
".",
"_smachine",
".",
"state",
"=",
"State",
".",
"CLOSING"
] | Close the XML stream and the underlying transport.
This gracefully shuts down the XML stream and the transport, if
possible by writing the eof using :meth:`asyncio.Transport.write_eof`
after sending the stream footer.
After a call to :meth:`close`, no other stream manipulating or sending
method can be called; doing so will result in a
:class:`ConnectionError` exception or any exception caused by the
transport during shutdown.
Calling :meth:`close` while the stream is closing or closed is a
no-op. | [
"Close",
"the",
"XML",
"stream",
"and",
"the",
"underlying",
"transport",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/protocol.py#L539-L565 |
785 | horazont/aioxmpp | aioxmpp/protocol.py | XMLStream.reset | def reset(self):
"""
Reset the stream by discarding all state and re-sending the stream
header.
Calling :meth:`reset` when the stream is disconnected or currently
disconnecting results in either :class:`ConnectionError` being raised
or the exception which caused the stream to die (possibly a received
stream error or a transport error) to be reraised.
:meth:`reset` puts the stream into :attr:`~State.STREAM_HEADER_SENT`
state and it cannot be used for sending XSOs until the peer stream
header has been received. Usually, this is not a problem as stream
resets only occur during stream negotiation and stream negotiation
typically waits for the peers feature node to arrive first.
"""
self._require_connection(accept_partial=True)
self._reset_state()
self._writer.start()
self._smachine.rewind(State.STREAM_HEADER_SENT) | python | def reset(self):
self._require_connection(accept_partial=True)
self._reset_state()
self._writer.start()
self._smachine.rewind(State.STREAM_HEADER_SENT) | [
"def",
"reset",
"(",
"self",
")",
":",
"self",
".",
"_require_connection",
"(",
"accept_partial",
"=",
"True",
")",
"self",
".",
"_reset_state",
"(",
")",
"self",
".",
"_writer",
".",
"start",
"(",
")",
"self",
".",
"_smachine",
".",
"rewind",
"(",
"State",
".",
"STREAM_HEADER_SENT",
")"
] | Reset the stream by discarding all state and re-sending the stream
header.
Calling :meth:`reset` when the stream is disconnected or currently
disconnecting results in either :class:`ConnectionError` being raised
or the exception which caused the stream to die (possibly a received
stream error or a transport error) to be reraised.
:meth:`reset` puts the stream into :attr:`~State.STREAM_HEADER_SENT`
state and it cannot be used for sending XSOs until the peer stream
header has been received. Usually, this is not a problem as stream
resets only occur during stream negotiation and stream negotiation
typically waits for the peers feature node to arrive first. | [
"Reset",
"the",
"stream",
"by",
"discarding",
"all",
"state",
"and",
"re",
"-",
"sending",
"the",
"stream",
"header",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/protocol.py#L613-L632 |
786 | horazont/aioxmpp | aioxmpp/protocol.py | XMLStream.abort | def abort(self):
"""
Abort the stream by writing an EOF if possible and closing the
transport.
The transport is closed using :meth:`asyncio.BaseTransport.close`, so
buffered data is sent, but no more data will be received. The stream is
in :attr:`State.CLOSED` state afterwards.
This also works if the stream is currently closing, that is, waiting
for the peer to send a stream footer. In that case, the stream will be
closed locally as if the stream footer had been received.
.. versionadded:: 0.5
"""
if self._smachine.state == State.CLOSED:
return
if self._smachine.state == State.READY:
self._smachine.state = State.CLOSED
return
if (self._smachine.state != State.CLOSING and
self._transport.can_write_eof()):
self._transport.write_eof()
self._close_transport() | python | def abort(self):
if self._smachine.state == State.CLOSED:
return
if self._smachine.state == State.READY:
self._smachine.state = State.CLOSED
return
if (self._smachine.state != State.CLOSING and
self._transport.can_write_eof()):
self._transport.write_eof()
self._close_transport() | [
"def",
"abort",
"(",
"self",
")",
":",
"if",
"self",
".",
"_smachine",
".",
"state",
"==",
"State",
".",
"CLOSED",
":",
"return",
"if",
"self",
".",
"_smachine",
".",
"state",
"==",
"State",
".",
"READY",
":",
"self",
".",
"_smachine",
".",
"state",
"=",
"State",
".",
"CLOSED",
"return",
"if",
"(",
"self",
".",
"_smachine",
".",
"state",
"!=",
"State",
".",
"CLOSING",
"and",
"self",
".",
"_transport",
".",
"can_write_eof",
"(",
")",
")",
":",
"self",
".",
"_transport",
".",
"write_eof",
"(",
")",
"self",
".",
"_close_transport",
"(",
")"
] | Abort the stream by writing an EOF if possible and closing the
transport.
The transport is closed using :meth:`asyncio.BaseTransport.close`, so
buffered data is sent, but no more data will be received. The stream is
in :attr:`State.CLOSED` state afterwards.
This also works if the stream is currently closing, that is, waiting
for the peer to send a stream footer. In that case, the stream will be
closed locally as if the stream footer had been received.
.. versionadded:: 0.5 | [
"Abort",
"the",
"stream",
"by",
"writing",
"an",
"EOF",
"if",
"possible",
"and",
"closing",
"the",
"transport",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/protocol.py#L634-L657 |
787 | horazont/aioxmpp | aioxmpp/protocol.py | XMLStream.starttls | def starttls(self, ssl_context, post_handshake_callback=None):
"""
Start TLS on the transport and wait for it to complete.
The `ssl_context` and `post_handshake_callback` arguments are forwarded
to the transports
:meth:`aioopenssl.STARTTLSTransport.starttls` coroutine method.
If the transport does not support starttls, :class:`RuntimeError` is
raised; support for starttls can be discovered by querying
:meth:`can_starttls`.
After :meth:`starttls` returns, you must call :meth:`reset`. Any other
method may fail in interesting ways as the internal state is discarded
when starttls succeeds, for security reasons. :meth:`reset` re-creates
the internal structures.
"""
self._require_connection()
if not self.can_starttls():
raise RuntimeError("starttls not available on transport")
yield from self._transport.starttls(ssl_context,
post_handshake_callback)
self._reset_state() | python | def starttls(self, ssl_context, post_handshake_callback=None):
self._require_connection()
if not self.can_starttls():
raise RuntimeError("starttls not available on transport")
yield from self._transport.starttls(ssl_context,
post_handshake_callback)
self._reset_state() | [
"def",
"starttls",
"(",
"self",
",",
"ssl_context",
",",
"post_handshake_callback",
"=",
"None",
")",
":",
"self",
".",
"_require_connection",
"(",
")",
"if",
"not",
"self",
".",
"can_starttls",
"(",
")",
":",
"raise",
"RuntimeError",
"(",
"\"starttls not available on transport\"",
")",
"yield",
"from",
"self",
".",
"_transport",
".",
"starttls",
"(",
"ssl_context",
",",
"post_handshake_callback",
")",
"self",
".",
"_reset_state",
"(",
")"
] | Start TLS on the transport and wait for it to complete.
The `ssl_context` and `post_handshake_callback` arguments are forwarded
to the transports
:meth:`aioopenssl.STARTTLSTransport.starttls` coroutine method.
If the transport does not support starttls, :class:`RuntimeError` is
raised; support for starttls can be discovered by querying
:meth:`can_starttls`.
After :meth:`starttls` returns, you must call :meth:`reset`. Any other
method may fail in interesting ways as the internal state is discarded
when starttls succeeds, for security reasons. :meth:`reset` re-creates
the internal structures. | [
"Start",
"TLS",
"on",
"the",
"transport",
"and",
"wait",
"for",
"it",
"to",
"complete",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/protocol.py#L699-L722 |
788 | horazont/aioxmpp | aioxmpp/protocol.py | XMLStream.error_future | def error_future(self):
"""
Return a future which will receive the next XML stream error as
exception.
It is safe to cancel the future at any time.
"""
fut = asyncio.Future(loop=self._loop)
self._error_futures.append(fut)
return fut | python | def error_future(self):
fut = asyncio.Future(loop=self._loop)
self._error_futures.append(fut)
return fut | [
"def",
"error_future",
"(",
"self",
")",
":",
"fut",
"=",
"asyncio",
".",
"Future",
"(",
"loop",
"=",
"self",
".",
"_loop",
")",
"self",
".",
"_error_futures",
".",
"append",
"(",
"fut",
")",
"return",
"fut"
] | Return a future which will receive the next XML stream error as
exception.
It is safe to cancel the future at any time. | [
"Return",
"a",
"future",
"which",
"will",
"receive",
"the",
"next",
"XML",
"stream",
"error",
"as",
"exception",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/protocol.py#L724-L733 |
789 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_features | def get_features(self, jid):
"""
Return the features supported by a service.
:param jid: Address of the PubSub service to query.
:type jid: :class:`aioxmpp.JID`
:return: Set of supported features
:rtype: set containing :class:`~.pubsub.xso.Feature` enumeration
members.
This simply uses service discovery to obtain the set of features and
converts the features to :class:`~.pubsub.xso.Feature` enumeration
members. To get the full feature information, resort to using
:meth:`.DiscoClient.query_info` directly on `jid`.
Features returned by the peer which are not valid pubsub features are
not returned.
"""
response = yield from self._disco.query_info(jid)
result = set()
for feature in response.features:
try:
result.add(pubsub_xso.Feature(feature))
except ValueError:
continue
return result | python | def get_features(self, jid):
response = yield from self._disco.query_info(jid)
result = set()
for feature in response.features:
try:
result.add(pubsub_xso.Feature(feature))
except ValueError:
continue
return result | [
"def",
"get_features",
"(",
"self",
",",
"jid",
")",
":",
"response",
"=",
"yield",
"from",
"self",
".",
"_disco",
".",
"query_info",
"(",
"jid",
")",
"result",
"=",
"set",
"(",
")",
"for",
"feature",
"in",
"response",
".",
"features",
":",
"try",
":",
"result",
".",
"add",
"(",
"pubsub_xso",
".",
"Feature",
"(",
"feature",
")",
")",
"except",
"ValueError",
":",
"continue",
"return",
"result"
] | Return the features supported by a service.
:param jid: Address of the PubSub service to query.
:type jid: :class:`aioxmpp.JID`
:return: Set of supported features
:rtype: set containing :class:`~.pubsub.xso.Feature` enumeration
members.
This simply uses service discovery to obtain the set of features and
converts the features to :class:`~.pubsub.xso.Feature` enumeration
members. To get the full feature information, resort to using
:meth:`.DiscoClient.query_info` directly on `jid`.
Features returned by the peer which are not valid pubsub features are
not returned. | [
"Return",
"the",
"features",
"supported",
"by",
"a",
"service",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L274-L300 |
790 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.subscribe | def subscribe(self, jid, node=None, *,
subscription_jid=None,
config=None):
"""
Subscribe to a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to subscribe to.
:type node: :class:`str`
:param subscription_jid: The address to subscribe to the service.
:type subscription_jid: :class:`aioxmpp.JID`
:param config: Optional configuration of the subscription
:type config: :class:`~.forms.Data`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The response from the server.
:rtype: :class:`.xso.Request`
By default, the subscription request will be for the bare JID of the
client. It can be specified explicitly using the `subscription_jid`
argument.
If the service requires it or if it makes sense for other reasons, the
subscription configuration :class:`~.forms.Data` form can be passed
using the `config` argument.
On success, the whole :class:`.xso.Request` object returned by the
server is returned. It contains a :class:`.xso.Subscription`
:attr:`~.xso.Request.payload` which has information on the nature of
the subscription (it may be ``"pending"`` or ``"unconfigured"``) and
the :attr:`~.xso.Subscription.subid` which may be required for other
operations.
On failure, the corresponding :class:`~.errors.XMPPError` is raised.
"""
subscription_jid = subscription_jid or self.client.local_jid.bare()
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Subscribe(subscription_jid, node=node)
)
if config is not None:
iq.payload.options = pubsub_xso.Options(
subscription_jid,
node=node
)
iq.payload.options.data = config
response = yield from self.client.send(iq)
return response | python | def subscribe(self, jid, node=None, *,
subscription_jid=None,
config=None):
subscription_jid = subscription_jid or self.client.local_jid.bare()
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Subscribe(subscription_jid, node=node)
)
if config is not None:
iq.payload.options = pubsub_xso.Options(
subscription_jid,
node=node
)
iq.payload.options.data = config
response = yield from self.client.send(iq)
return response | [
"def",
"subscribe",
"(",
"self",
",",
"jid",
",",
"node",
"=",
"None",
",",
"*",
",",
"subscription_jid",
"=",
"None",
",",
"config",
"=",
"None",
")",
":",
"subscription_jid",
"=",
"subscription_jid",
"or",
"self",
".",
"client",
".",
"local_jid",
".",
"bare",
"(",
")",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"SET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"pubsub_xso",
".",
"Subscribe",
"(",
"subscription_jid",
",",
"node",
"=",
"node",
")",
")",
"if",
"config",
"is",
"not",
"None",
":",
"iq",
".",
"payload",
".",
"options",
"=",
"pubsub_xso",
".",
"Options",
"(",
"subscription_jid",
",",
"node",
"=",
"node",
")",
"iq",
".",
"payload",
".",
"options",
".",
"data",
"=",
"config",
"response",
"=",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
"return",
"response"
] | Subscribe to a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to subscribe to.
:type node: :class:`str`
:param subscription_jid: The address to subscribe to the service.
:type subscription_jid: :class:`aioxmpp.JID`
:param config: Optional configuration of the subscription
:type config: :class:`~.forms.Data`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The response from the server.
:rtype: :class:`.xso.Request`
By default, the subscription request will be for the bare JID of the
client. It can be specified explicitly using the `subscription_jid`
argument.
If the service requires it or if it makes sense for other reasons, the
subscription configuration :class:`~.forms.Data` form can be passed
using the `config` argument.
On success, the whole :class:`.xso.Request` object returned by the
server is returned. It contains a :class:`.xso.Subscription`
:attr:`~.xso.Request.payload` which has information on the nature of
the subscription (it may be ``"pending"`` or ``"unconfigured"``) and
the :attr:`~.xso.Subscription.subid` which may be required for other
operations.
On failure, the corresponding :class:`~.errors.XMPPError` is raised. | [
"Subscribe",
"to",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L303-L354 |
791 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.unsubscribe | def unsubscribe(self, jid, node=None, *,
subscription_jid=None,
subid=None):
"""
Unsubscribe from a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to unsubscribe from.
:type node: :class:`str`
:param subscription_jid: The address to subscribe from the service.
:type subscription_jid: :class:`aioxmpp.JID`
:param subid: Unique ID of the subscription to remove.
:type subid: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
By default, the unsubscribe request will be for the bare JID of the
client. It can be specified explicitly using the `subscription_jid`
argument.
If available, the `subid` should also be specified.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised.
"""
subscription_jid = subscription_jid or self.client.local_jid.bare()
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Unsubscribe(subscription_jid, node=node, subid=subid)
)
yield from self.client.send(iq) | python | def unsubscribe(self, jid, node=None, *,
subscription_jid=None,
subid=None):
subscription_jid = subscription_jid or self.client.local_jid.bare()
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Unsubscribe(subscription_jid, node=node, subid=subid)
)
yield from self.client.send(iq) | [
"def",
"unsubscribe",
"(",
"self",
",",
"jid",
",",
"node",
"=",
"None",
",",
"*",
",",
"subscription_jid",
"=",
"None",
",",
"subid",
"=",
"None",
")",
":",
"subscription_jid",
"=",
"subscription_jid",
"or",
"self",
".",
"client",
".",
"local_jid",
".",
"bare",
"(",
")",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"SET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"pubsub_xso",
".",
"Unsubscribe",
"(",
"subscription_jid",
",",
"node",
"=",
"node",
",",
"subid",
"=",
"subid",
")",
")",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")"
] | Unsubscribe from a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to unsubscribe from.
:type node: :class:`str`
:param subscription_jid: The address to subscribe from the service.
:type subscription_jid: :class:`aioxmpp.JID`
:param subid: Unique ID of the subscription to remove.
:type subid: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
By default, the unsubscribe request will be for the bare JID of the
client. It can be specified explicitly using the `subscription_jid`
argument.
If available, the `subid` should also be specified.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised. | [
"Unsubscribe",
"from",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L357-L390 |
792 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_subscription_config | def get_subscription_config(self, jid, node=None, *,
subscription_jid=None,
subid=None):
"""
Request the current configuration of a subscription.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:param subscription_jid: The address to query the configuration for.
:type subscription_jid: :class:`aioxmpp.JID`
:param subid: Unique ID of the subscription to query.
:type subid: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The current configuration of the subscription.
:rtype: :class:`~.forms.Data`
By default, the request will be on behalf of the bare JID of the
client. It can be overriden using the `subscription_jid` argument.
If available, the `subid` should also be specified.
On success, the :class:`~.forms.Data` form is returned.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised.
"""
subscription_jid = subscription_jid or self.client.local_jid.bare()
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request()
iq.payload.options = pubsub_xso.Options(
subscription_jid,
node=node,
subid=subid,
)
response = yield from self.client.send(iq)
return response.options.data | python | def get_subscription_config(self, jid, node=None, *,
subscription_jid=None,
subid=None):
subscription_jid = subscription_jid or self.client.local_jid.bare()
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request()
iq.payload.options = pubsub_xso.Options(
subscription_jid,
node=node,
subid=subid,
)
response = yield from self.client.send(iq)
return response.options.data | [
"def",
"get_subscription_config",
"(",
"self",
",",
"jid",
",",
"node",
"=",
"None",
",",
"*",
",",
"subscription_jid",
"=",
"None",
",",
"subid",
"=",
"None",
")",
":",
"subscription_jid",
"=",
"subscription_jid",
"or",
"self",
".",
"client",
".",
"local_jid",
".",
"bare",
"(",
")",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"GET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
")",
"iq",
".",
"payload",
".",
"options",
"=",
"pubsub_xso",
".",
"Options",
"(",
"subscription_jid",
",",
"node",
"=",
"node",
",",
"subid",
"=",
"subid",
",",
")",
"response",
"=",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
"return",
"response",
".",
"options",
".",
"data"
] | Request the current configuration of a subscription.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:param subscription_jid: The address to query the configuration for.
:type subscription_jid: :class:`aioxmpp.JID`
:param subid: Unique ID of the subscription to query.
:type subid: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The current configuration of the subscription.
:rtype: :class:`~.forms.Data`
By default, the request will be on behalf of the bare JID of the
client. It can be overriden using the `subscription_jid` argument.
If available, the `subid` should also be specified.
On success, the :class:`~.forms.Data` form is returned.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised. | [
"Request",
"the",
"current",
"configuration",
"of",
"a",
"subscription",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L393-L433 |
793 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_default_config | def get_default_config(self, jid, node=None):
"""
Request the default configuration of a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The default configuration of subscriptions at the node.
:rtype: :class:`~.forms.Data`
On success, the :class:`~.forms.Data` form is returned.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised.
"""
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Default(node=node)
)
response = yield from self.client.send(iq)
return response.payload.data | python | def get_default_config(self, jid, node=None):
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Default(node=node)
)
response = yield from self.client.send(iq)
return response.payload.data | [
"def",
"get_default_config",
"(",
"self",
",",
"jid",
",",
"node",
"=",
"None",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"GET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"pubsub_xso",
".",
"Default",
"(",
"node",
"=",
"node",
")",
")",
"response",
"=",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
"return",
"response",
".",
"payload",
".",
"data"
] | Request the default configuration of a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The default configuration of subscriptions at the node.
:rtype: :class:`~.forms.Data`
On success, the :class:`~.forms.Data` form is returned.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised. | [
"Request",
"the",
"default",
"configuration",
"of",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L480-L504 |
794 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_node_config | def get_node_config(self, jid, node=None):
"""
Request the configuration of a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The configuration of the node.
:rtype: :class:`~.forms.Data`
On success, the :class:`~.forms.Data` form is returned.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised.
"""
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.OwnerRequest(
pubsub_xso.OwnerConfigure(node=node)
)
response = yield from self.client.send(iq)
return response.payload.data | python | def get_node_config(self, jid, node=None):
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.OwnerRequest(
pubsub_xso.OwnerConfigure(node=node)
)
response = yield from self.client.send(iq)
return response.payload.data | [
"def",
"get_node_config",
"(",
"self",
",",
"jid",
",",
"node",
"=",
"None",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"GET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"OwnerRequest",
"(",
"pubsub_xso",
".",
"OwnerConfigure",
"(",
"node",
"=",
"node",
")",
")",
"response",
"=",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
"return",
"response",
".",
"payload",
".",
"data"
] | Request the configuration of a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The configuration of the node.
:rtype: :class:`~.forms.Data`
On success, the :class:`~.forms.Data` form is returned.
If an error occurs, the corresponding :class:`~.errors.XMPPError` is
raised. | [
"Request",
"the",
"configuration",
"of",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L507-L531 |
795 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.set_node_config | def set_node_config(self, jid, config, node=None):
"""
Update the configuration of a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param config: Configuration form
:type config: :class:`aioxmpp.forms.Data`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The configuration of the node.
:rtype: :class:`~.forms.Data`
.. seealso::
:class:`aioxmpp.pubsub.NodeConfigForm`
"""
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.OwnerRequest(
pubsub_xso.OwnerConfigure(node=node)
)
iq.payload.payload.data = config
yield from self.client.send(iq) | python | def set_node_config(self, jid, config, node=None):
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.OwnerRequest(
pubsub_xso.OwnerConfigure(node=node)
)
iq.payload.payload.data = config
yield from self.client.send(iq) | [
"def",
"set_node_config",
"(",
"self",
",",
"jid",
",",
"config",
",",
"node",
"=",
"None",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"SET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"OwnerRequest",
"(",
"pubsub_xso",
".",
"OwnerConfigure",
"(",
"node",
"=",
"node",
")",
")",
"iq",
".",
"payload",
".",
"payload",
".",
"data",
"=",
"config",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")"
] | Update the configuration of a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param config: Configuration form
:type config: :class:`aioxmpp.forms.Data`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The configuration of the node.
:rtype: :class:`~.forms.Data`
.. seealso::
:class:`aioxmpp.pubsub.NodeConfigForm` | [
"Update",
"the",
"configuration",
"of",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L534-L559 |
796 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_items | def get_items(self, jid, node, *, max_items=None):
"""
Request the most recent items from a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:param max_items: Number of items to return at most.
:type max_items: :class:`int` or :data:`None`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The response from the server.
:rtype: :class:`.xso.Request`.
By default, as many as possible items are requested. If `max_items` is
given, it must be a positive integer specifying the maximum number of
items which is to be returned by the server.
Return the :class:`.xso.Request` object, which has a
:class:`~.xso.Items` :attr:`~.xso.Request.payload`.
"""
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Items(node, max_items=max_items)
)
return (yield from self.client.send(iq)) | python | def get_items(self, jid, node, *, max_items=None):
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Items(node, max_items=max_items)
)
return (yield from self.client.send(iq)) | [
"def",
"get_items",
"(",
"self",
",",
"jid",
",",
"node",
",",
"*",
",",
"max_items",
"=",
"None",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"GET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"pubsub_xso",
".",
"Items",
"(",
"node",
",",
"max_items",
"=",
"max_items",
")",
")",
"return",
"(",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
")"
] | Request the most recent items from a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:param max_items: Number of items to return at most.
:type max_items: :class:`int` or :data:`None`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The response from the server.
:rtype: :class:`.xso.Request`.
By default, as many as possible items are requested. If `max_items` is
given, it must be a positive integer specifying the maximum number of
items which is to be returned by the server.
Return the :class:`.xso.Request` object, which has a
:class:`~.xso.Items` :attr:`~.xso.Request.payload`. | [
"Request",
"the",
"most",
"recent",
"items",
"from",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L562-L589 |
797 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_items_by_id | def get_items_by_id(self, jid, node, ids):
"""
Request specific items by their IDs from a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:param ids: The item IDs to return.
:type ids: :class:`~collections.abc.Iterable` of :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The response from the service
:rtype: :class:`.xso.Request`
`ids` must be an iterable of :class:`str` of the IDs of the items to
request from the pubsub node. If the iterable is empty,
:class:`ValueError` is raised (as otherwise, the request would be
identical to calling :meth:`get_items` without `max_items`).
Return the :class:`.xso.Request` object, which has a
:class:`~.xso.Items` :attr:`~.xso.Request.payload`.
"""
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Items(node)
)
iq.payload.payload.items = [
pubsub_xso.Item(id_)
for id_ in ids
]
if not iq.payload.payload.items:
raise ValueError("ids must not be empty")
return (yield from self.client.send(iq)) | python | def get_items_by_id(self, jid, node, ids):
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Items(node)
)
iq.payload.payload.items = [
pubsub_xso.Item(id_)
for id_ in ids
]
if not iq.payload.payload.items:
raise ValueError("ids must not be empty")
return (yield from self.client.send(iq)) | [
"def",
"get_items_by_id",
"(",
"self",
",",
"jid",
",",
"node",
",",
"ids",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"GET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"pubsub_xso",
".",
"Items",
"(",
"node",
")",
")",
"iq",
".",
"payload",
".",
"payload",
".",
"items",
"=",
"[",
"pubsub_xso",
".",
"Item",
"(",
"id_",
")",
"for",
"id_",
"in",
"ids",
"]",
"if",
"not",
"iq",
".",
"payload",
".",
"payload",
".",
"items",
":",
"raise",
"ValueError",
"(",
"\"ids must not be empty\"",
")",
"return",
"(",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
")"
] | Request specific items by their IDs from a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:param ids: The item IDs to return.
:type ids: :class:`~collections.abc.Iterable` of :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The response from the service
:rtype: :class:`.xso.Request`
`ids` must be an iterable of :class:`str` of the IDs of the items to
request from the pubsub node. If the iterable is empty,
:class:`ValueError` is raised (as otherwise, the request would be
identical to calling :meth:`get_items` without `max_items`).
Return the :class:`.xso.Request` object, which has a
:class:`~.xso.Items` :attr:`~.xso.Request.payload`. | [
"Request",
"specific",
"items",
"by",
"their",
"IDs",
"from",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L592-L628 |
798 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.get_subscriptions | def get_subscriptions(self, jid, node=None):
"""
Return all subscriptions of the local entity to a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The subscriptions response from the service.
:rtype: :class:`.xso.Subscriptions.
If `node` is :data:`None`, subscriptions on all nodes of the entity
`jid` are listed.
"""
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Subscriptions(node=node)
)
response = yield from self.client.send(iq)
return response.payload | python | def get_subscriptions(self, jid, node=None):
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.GET)
iq.payload = pubsub_xso.Request(
pubsub_xso.Subscriptions(node=node)
)
response = yield from self.client.send(iq)
return response.payload | [
"def",
"get_subscriptions",
"(",
"self",
",",
"jid",
",",
"node",
"=",
"None",
")",
":",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"GET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"pubsub_xso",
".",
"Subscriptions",
"(",
"node",
"=",
"node",
")",
")",
"response",
"=",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
"return",
"response",
".",
"payload"
] | Return all subscriptions of the local entity to a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to query.
:type node: :class:`str`
:raises aioxmpp.errors.XMPPError: as returned by the service
:return: The subscriptions response from the service.
:rtype: :class:`.xso.Subscriptions.
If `node` is :data:`None`, subscriptions on all nodes of the entity
`jid` are listed. | [
"Return",
"all",
"subscriptions",
"of",
"the",
"local",
"entity",
"to",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L631-L653 |
799 | horazont/aioxmpp | aioxmpp/pubsub/service.py | PubSubClient.publish | def publish(self, jid, node, payload, *,
id_=None,
publish_options=None):
"""
Publish an item to a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to publish to.
:type node: :class:`str`
:param payload: Registered payload to publish.
:type payload: :class:`aioxmpp.xso.XSO`
:param id_: Item ID to use for the item.
:type id_: :class:`str` or :data:`None`.
:param publish_options: A data form with the options for the publish
request
:type publish_options: :class:`aioxmpp.forms.Data`
:raises aioxmpp.errors.XMPPError: as returned by the service
:raises RuntimeError: if `publish_options` is not :data:`None` but
the service does not support `publish_options`
:return: The Item ID which was used to publish the item.
:rtype: :class:`str` or :data:`None`
Publish the given `payload` (which must be a :class:`aioxmpp.xso.XSO`
registered with :attr:`.xso.Item.registered_payload`).
The item is published to `node` at `jid`. If `id_` is given, it is used
as the ID for the item. If an item with the same ID already exists at
the node, it is replaced. If no ID is given, a ID is generated by the
server.
If `publish_options` is given, it is passed as ``<publish-options/>``
element to the server. This needs to be a data form which allows to
define e.g. node configuration as a pre-condition to publishing. If
the publish-options cannot be satisfied, the server will raise a
:attr:`aioxmpp.ErrorCondition.CONFLICT` error.
If `publish_options` is given and the server does not announce the
:attr:`aioxmpp.pubsub.xso.Feature.PUBLISH_OPTIONS` feature,
:class:`RuntimeError` is raised to prevent security issues (e.g. if
the publish options attempt to assert a restrictive access model).
Return the ID of the item as published (or :data:`None` if the server
does not inform us; this is unfortunately common).
"""
publish = pubsub_xso.Publish()
publish.node = node
if payload is not None:
item = pubsub_xso.Item()
item.id_ = id_
item.registered_payload = payload
publish.item = item
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.Request(
publish
)
if publish_options is not None:
features = yield from self.get_features(jid)
if pubsub_xso.Feature.PUBLISH_OPTIONS not in features:
raise RuntimeError(
"publish-options given, but not supported by server"
)
iq.payload.publish_options = pubsub_xso.PublishOptions()
iq.payload.publish_options.data = publish_options
response = yield from self.client.send(iq)
if response is not None and response.payload.item is not None:
return response.payload.item.id_ or id_
return id_ | python | def publish(self, jid, node, payload, *,
id_=None,
publish_options=None):
publish = pubsub_xso.Publish()
publish.node = node
if payload is not None:
item = pubsub_xso.Item()
item.id_ = id_
item.registered_payload = payload
publish.item = item
iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET)
iq.payload = pubsub_xso.Request(
publish
)
if publish_options is not None:
features = yield from self.get_features(jid)
if pubsub_xso.Feature.PUBLISH_OPTIONS not in features:
raise RuntimeError(
"publish-options given, but not supported by server"
)
iq.payload.publish_options = pubsub_xso.PublishOptions()
iq.payload.publish_options.data = publish_options
response = yield from self.client.send(iq)
if response is not None and response.payload.item is not None:
return response.payload.item.id_ or id_
return id_ | [
"def",
"publish",
"(",
"self",
",",
"jid",
",",
"node",
",",
"payload",
",",
"*",
",",
"id_",
"=",
"None",
",",
"publish_options",
"=",
"None",
")",
":",
"publish",
"=",
"pubsub_xso",
".",
"Publish",
"(",
")",
"publish",
".",
"node",
"=",
"node",
"if",
"payload",
"is",
"not",
"None",
":",
"item",
"=",
"pubsub_xso",
".",
"Item",
"(",
")",
"item",
".",
"id_",
"=",
"id_",
"item",
".",
"registered_payload",
"=",
"payload",
"publish",
".",
"item",
"=",
"item",
"iq",
"=",
"aioxmpp",
".",
"stanza",
".",
"IQ",
"(",
"to",
"=",
"jid",
",",
"type_",
"=",
"aioxmpp",
".",
"structs",
".",
"IQType",
".",
"SET",
")",
"iq",
".",
"payload",
"=",
"pubsub_xso",
".",
"Request",
"(",
"publish",
")",
"if",
"publish_options",
"is",
"not",
"None",
":",
"features",
"=",
"yield",
"from",
"self",
".",
"get_features",
"(",
"jid",
")",
"if",
"pubsub_xso",
".",
"Feature",
".",
"PUBLISH_OPTIONS",
"not",
"in",
"features",
":",
"raise",
"RuntimeError",
"(",
"\"publish-options given, but not supported by server\"",
")",
"iq",
".",
"payload",
".",
"publish_options",
"=",
"pubsub_xso",
".",
"PublishOptions",
"(",
")",
"iq",
".",
"payload",
".",
"publish_options",
".",
"data",
"=",
"publish_options",
"response",
"=",
"yield",
"from",
"self",
".",
"client",
".",
"send",
"(",
"iq",
")",
"if",
"response",
"is",
"not",
"None",
"and",
"response",
".",
"payload",
".",
"item",
"is",
"not",
"None",
":",
"return",
"response",
".",
"payload",
".",
"item",
".",
"id_",
"or",
"id_",
"return",
"id_"
] | Publish an item to a node.
:param jid: Address of the PubSub service.
:type jid: :class:`aioxmpp.JID`
:param node: Name of the PubSub node to publish to.
:type node: :class:`str`
:param payload: Registered payload to publish.
:type payload: :class:`aioxmpp.xso.XSO`
:param id_: Item ID to use for the item.
:type id_: :class:`str` or :data:`None`.
:param publish_options: A data form with the options for the publish
request
:type publish_options: :class:`aioxmpp.forms.Data`
:raises aioxmpp.errors.XMPPError: as returned by the service
:raises RuntimeError: if `publish_options` is not :data:`None` but
the service does not support `publish_options`
:return: The Item ID which was used to publish the item.
:rtype: :class:`str` or :data:`None`
Publish the given `payload` (which must be a :class:`aioxmpp.xso.XSO`
registered with :attr:`.xso.Item.registered_payload`).
The item is published to `node` at `jid`. If `id_` is given, it is used
as the ID for the item. If an item with the same ID already exists at
the node, it is replaced. If no ID is given, a ID is generated by the
server.
If `publish_options` is given, it is passed as ``<publish-options/>``
element to the server. This needs to be a data form which allows to
define e.g. node configuration as a pre-condition to publishing. If
the publish-options cannot be satisfied, the server will raise a
:attr:`aioxmpp.ErrorCondition.CONFLICT` error.
If `publish_options` is given and the server does not announce the
:attr:`aioxmpp.pubsub.xso.Feature.PUBLISH_OPTIONS` feature,
:class:`RuntimeError` is raised to prevent security issues (e.g. if
the publish options attempt to assert a restrictive access model).
Return the ID of the item as published (or :data:`None` if the server
does not inform us; this is unfortunately common). | [
"Publish",
"an",
"item",
"to",
"a",
"node",
"."
] | 22a68e5e1d23f2a4dee470092adbd4672f9ef061 | https://github.com/horazont/aioxmpp/blob/22a68e5e1d23f2a4dee470092adbd4672f9ef061/aioxmpp/pubsub/service.py#L656-L730 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.