desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Returns string representation of this message.'
| def __str__(self):
| return u'Authenticate(signature={0}, extra={1})'.format(self.signature, self.extra)
|
':param reason: Optional WAMP or application error URI for closing reason.
:type reason: str
:param message: Optional human-readable closing message, e.g. for logging purposes.
:type message: str or None
:param resumable: From the server: Whether the session is able to be resumed (true) or destroyed (false). From the c... | def __init__(self, reason=DEFAULT_REASON, message=None, resumable=None):
| assert (type(reason) == six.text_type)
assert ((message is None) or (type(message) == six.text_type))
assert ((resumable is None) or (type(resumable) == bool))
Message.__init__(self)
self.reason = reason
self.message = message
self.resumable = resumable
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Goodbye.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for GOODBYE'.format(len(wmsg)))
details = check_or_raise_extra(wmsg[1], u"'details' in GOODBYE")
reason = check_or_raise_uri(wmsg[2], u"'reason... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| details = {}
if self.message:
details[u'message'] = self.message
if self.resumable:
details[u'resumable'] = self.resumable
return [Goodbye.MESSAGE_TYPE, details, self.reason]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Goodbye(message={}, reason={}, resumable={})'.format(self.message, self.reason, self.resumable)
|
':param request_type: The WAMP message type code for the original request.
:type request_type: int
:param request: The WAMP request ID of the original request (`Call`, `Subscribe`, ...) this error occurred for.
:type request: int
:param error: The WAMP or application error URI for the error that occurred.
:type error: ... | def __init__(self, request_type, request, error, args=None, kwargs=None, payload=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(request_type) in six.integer_types)
assert (type(request) in six.integer_types)
assert (type(error) == six.text_type)
assert ((args is None) or (type(args) in [list, tuple]))
assert ((kwargs is None) or (type(kwargs) == dict))
assert ((payload is None) or (type(payload) == six.binar... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Error.MESSAGE_TYPE))
if (len(wmsg) not in (5, 6, 7)):
raise ProtocolError('invalid message length {0} for ERROR'.format(len(wmsg)))
request_type = wmsg[1]
if (type(request_type) not in six.integer_types):
raise ProtocolError("invalid... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| details = {}
if self.payload:
if (self.enc_algo is not None):
details[u'enc_algo'] = self.enc_algo
if (self.enc_key is not None):
details[u'enc_key'] = self.enc_key
if (self.enc_serializer is not None):
details[u'enc_serializer'] = self.enc_serializer
... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Error(request_type={0}, request={1}, error={2}, args={3}, kwargs={4}, enc_algo={5}, enc_key={6}, enc_serializer={7}, payload={8})'.format(self.request_type, self.request, self.error, self.args, self.kwargs, self.enc_algo, self.enc_key, self.enc_serializer, b2a(self.payload))
|
':param request: The WAMP request ID of this request.
:type request: int
:param topic: The WAMP or application URI of the PubSub topic the event should
be published to.
:type topic: str
:param args: Positional values for application-defined event payload.
Must be serializable using any serializers in use.
:type args: l... | def __init__(self, request, topic, args=None, kwargs=None, payload=None, acknowledge=None, exclude_me=None, exclude=None, exclude_authid=None, exclude_authrole=None, eligible=None, eligible_authid=None, eligible_authrole=None, retain=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(request) in six.integer_types)
assert (type(topic) == six.text_type)
assert ((args is None) or (type(args) in [list, tuple, six.text_type, six.binary_type]))
assert ((kwargs is None) or (type(kwargs) in [dict, six.text_type, six.binary_type]))
assert ((payload is None) or (type(payload)... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Publish.MESSAGE_TYPE))
if (len(wmsg) not in (4, 5, 6)):
raise ProtocolError('invalid message length {0} for PUBLISH'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in PUBLISH")
options = check_or_raise_extra(wmsg[2... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| options = self.marshal_options()
if self.payload:
return [Publish.MESSAGE_TYPE, self.request, options, self.topic, self.payload]
elif self.kwargs:
return [Publish.MESSAGE_TYPE, self.request, options, self.topic, self.args, self.kwargs]
elif self.args:
return [Publish.MESSAGE_TYPE... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Publish(request={}, topic={}, args={}, kwargs={}, acknowledge={}, exclude_me={}, exclude={}, exclude_authid={}, exclude_authrole={}, eligible={}, eligible_authid={}, eligible_authrole={}, retain={}, enc_algo={}, enc_key={}, enc_serializer={}, payload={})'.for... |
':param request: The request ID of the original `PUBLISH` request.
:type request: int
:param publication: The publication ID for the published event.
:type publication: int'
| def __init__(self, request, publication):
| assert (type(request) in six.integer_types)
assert (type(publication) in six.integer_types)
Message.__init__(self)
self.request = request
self.publication = publication
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Published.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for PUBLISHED'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in PUBLISHED")
publication = check_or_raise_id(wmsg[2], u"... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Published.MESSAGE_TYPE, self.request, self.publication]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Published(request={0}, publication={1})'.format(self.request, self.publication)
|
':param request: The WAMP request ID of this request.
:type request: int
:param topic: The WAMP or application URI of the PubSub topic to subscribe to.
:type topic: str
:param match: The topic matching method to be used for the subscription.
:type match: str
:param get_retained: Whether the client wants the retained me... | def __init__(self, request, topic, match=None, get_retained=None):
| assert (type(request) in six.integer_types)
assert (type(topic) == six.text_type)
assert ((match is None) or (type(match) == six.text_type))
assert ((match is None) or (match in [Subscribe.MATCH_EXACT, Subscribe.MATCH_PREFIX, Subscribe.MATCH_WILDCARD]))
assert ((get_retained is None) or (type(get_re... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Subscribe.MESSAGE_TYPE))
if (len(wmsg) != 4):
raise ProtocolError('invalid message length {0} for SUBSCRIBE'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in SUBSCRIBE")
options = check_or_raise_extra(wmsg[2], u"'... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Subscribe.MESSAGE_TYPE, self.request, self.marshal_options(), self.topic]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Subscribe(request={0}, topic={1}, match={2}, get_retained={3})'.format(self.request, self.topic, self.match, self.get_retained)
|
':param request: The request ID of the original ``SUBSCRIBE`` request.
:type request: int
:param subscription: The subscription ID for the subscribed topic (or topic pattern).
:type subscription: int'
| def __init__(self, request, subscription):
| assert (type(request) in six.integer_types)
assert (type(subscription) in six.integer_types)
Message.__init__(self)
self.request = request
self.subscription = subscription
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Subscribed.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for SUBSCRIBED'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in SUBSCRIBED")
subscription = check_or_raise_id(wmsg[2]... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Subscribed.MESSAGE_TYPE, self.request, self.subscription]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Subscribed(request={0}, subscription={1})'.format(self.request, self.subscription)
|
':param request: The WAMP request ID of this request.
:type request: int
:param subscription: The subscription ID for the subscription to unsubscribe from.
:type subscription: int'
| def __init__(self, request, subscription):
| assert (type(request) in six.integer_types)
assert (type(subscription) in six.integer_types)
Message.__init__(self)
self.request = request
self.subscription = subscription
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Unsubscribe.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for WAMP UNSUBSCRIBE'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in UNSUBSCRIBE")
subscription = check_or_raise... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Unsubscribe.MESSAGE_TYPE, self.request, self.subscription]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Unsubscribe(request={0}, subscription={1})'.format(self.request, self.subscription)
|
':param request: The request ID of the original ``UNSUBSCRIBE`` request or
``0`` is router triggered unsubscribe ("router revocation signaling").
:type request: int
:param subscription: If unsubscribe was actively triggered by router, the ID
of the subscription revoked.
:type subscription: int or None
:param reason: Th... | def __init__(self, request, subscription=None, reason=None):
| assert (type(request) in six.integer_types)
assert ((subscription is None) or (type(subscription) in six.integer_types))
assert ((reason is None) or (type(reason) == six.text_type))
assert (((request != 0) and (subscription is None)) or ((request == 0) and (subscription != 0)))
Message.__init__(self... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Unsubscribed.MESSAGE_TYPE))
if (len(wmsg) not in [2, 3]):
raise ProtocolError('invalid message length {0} for UNSUBSCRIBED'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in UNSUBSCRIBED")
subscription = None
r... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| if ((self.reason is not None) or (self.subscription is not None)):
details = {}
if (self.reason is not None):
details[u'reason'] = self.reason
if (self.subscription is not None):
details[u'subscription'] = self.subscription
return [Unsubscribed.MESSAGE_TYPE, s... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Unsubscribed(request={0}, reason={1}, subscription={2})'.format(self.request, self.reason, self.subscription)
|
':param subscription: The subscription ID this event is dispatched under.
:type subscription: int
:param publication: The publication ID of the dispatched event.
:type publication: int
:param args: Positional values for application-defined exception.
Must be serializable using any serializers in use.
:type args: list o... | def __init__(self, subscription, publication, args=None, kwargs=None, payload=None, publisher=None, publisher_authid=None, publisher_authrole=None, topic=None, retained=None, x_acknowledged_delivery=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(subscription) in six.integer_types)
assert (type(publication) in six.integer_types)
assert ((args is None) or (type(args) in [list, tuple]))
assert ((kwargs is None) or (type(kwargs) == dict))
assert ((payload is None) or (type(payload) == six.binary_type))
assert ((payload is None)... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Event.MESSAGE_TYPE))
if (len(wmsg) not in (4, 5, 6)):
raise ProtocolError('invalid message length {0} for EVENT'.format(len(wmsg)))
subscription = check_or_raise_id(wmsg[1], u"'subscription' in EVENT")
publication = check_or_raise_id(w... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| details = {}
if (self.publisher is not None):
details[u'publisher'] = self.publisher
if (self.publisher_authid is not None):
details[u'publisher_authid'] = self.publisher_authid
if (self.publisher_authrole is not None):
details[u'publisher_authrole'] = self.publisher_authrole
... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Event(subscription={}, publication={}, args={}, kwargs={}, publisher={}, publisher_authid={}, publisher_authrole={}, topic={}, retained={}, enc_algo={}, enc_key={}, enc_serializer={}, payload={})'.format(self.subscription, self.publication, self.args, self.kwargs, self.p... |
':param publication: The publication ID for the sent event.
:type publication: int'
| def __init__(self, publication):
| assert (type(publication) in six.integer_types)
Message.__init__(self)
self.publication = publication
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == EventReceived.MESSAGE_TYPE))
if (len(wmsg) != 2):
raise ProtocolError('invalid message length {0} for EVENT_RECEIVED'.format(len(wmsg)))
publication = check_or_raise_id(wmsg[1], u"'publication' in EVENT_RECEIVED")
obj = EventReceived(p... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [EventReceived.MESSAGE_TYPE, self.publication]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'EventReceived(publication={})'.format(self.publication)
|
':param request: The WAMP request ID of this request.
:type request: int
:param procedure: The WAMP or application URI of the procedure which should be called.
:type procedure: str
:param args: Positional values for application-defined call arguments.
Must be serializable using any serializers in use.
:type args: list ... | def __init__(self, request, procedure, args=None, kwargs=None, payload=None, timeout=None, receive_progress=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(request) in six.integer_types)
assert (type(procedure) == six.text_type)
assert ((args is None) or (type(args) in [list, tuple]))
assert ((kwargs is None) or (type(kwargs) == dict))
assert ((payload is None) or (type(payload) == six.binary_type))
assert ((payload is None) or ((paylo... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Call.MESSAGE_TYPE))
if (len(wmsg) not in (4, 5, 6)):
raise ProtocolError('invalid message length {0} for CALL'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in CALL")
options = check_or_raise_extra(wmsg[2], u"'opt... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| options = self.marshal_options()
if self.payload:
return [Call.MESSAGE_TYPE, self.request, options, self.procedure, self.payload]
elif self.kwargs:
return [Call.MESSAGE_TYPE, self.request, options, self.procedure, self.args, self.kwargs]
elif self.args:
return [Call.MESSAGE_TYPE,... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Call(request={0}, procedure={1}, args={2}, kwargs={3}, timeout={4}, receive_progress={5}, enc_algo={6}, enc_key={7}, enc_serializer={8}, payload={9})'.format(self.request, self.procedure, self.args, self.kwargs, self.timeout, self.receive_progress, self.enc_algo, self.enc_key, se... |
':param request: The WAMP request ID of the original `CALL` to cancel.
:type request: int
:param mode: Specifies how to cancel the call (``"skip"``, ``"abort"`` or ``"kill"``).
:type mode: str or None'
| def __init__(self, request, mode=None):
| assert (type(request) in six.integer_types)
assert ((mode is None) or (type(mode) == six.text_type))
assert (mode in [None, self.SKIP, self.ABORT, self.KILL])
Message.__init__(self)
self.request = request
self.mode = mode
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Cancel.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for CANCEL'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in CANCEL")
options = check_or_raise_extra(wmsg[2], u"'options' ... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| options = {}
if (self.mode is not None):
options[u'mode'] = self.mode
return [Cancel.MESSAGE_TYPE, self.request, options]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Cancel(request={0}, mode={1})'.format(self.request, self.mode)
|
':param request: The request ID of the original `CALL` request.
:type request: int
:param args: Positional values for application-defined event payload.
Must be serializable using any serializers in use.
:type args: list or tuple or None
:param kwargs: Keyword values for application-defined event payload.
Must be seria... | def __init__(self, request, args=None, kwargs=None, payload=None, progress=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(request) in six.integer_types)
assert ((args is None) or (type(args) in [list, tuple]))
assert ((kwargs is None) or (type(kwargs) == dict))
assert ((payload is None) or (type(payload) == six.binary_type))
assert ((payload is None) or ((payload is not None) and (args is None) and (kwargs... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Result.MESSAGE_TYPE))
if (len(wmsg) not in (3, 4, 5)):
raise ProtocolError('invalid message length {0} for RESULT'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in RESULT")
details = check_or_raise_extra(wmsg[2], ... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| details = {}
if (self.progress is not None):
details[u'progress'] = self.progress
if self.payload:
if (self.enc_algo is not None):
details[u'enc_algo'] = self.enc_algo
if (self.enc_key is not None):
details[u'enc_key'] = self.enc_key
if (self.enc_seria... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Result(request={0}, args={1}, kwargs={2}, progress={3}, enc_algo={4}, enc_key={5}, enc_serializer={6}, payload={7})'.format(self.request, self.args, self.kwargs, self.progress, self.enc_algo, self.enc_key, self.enc_serializer, b2a(self.payload))
|
':param request: The WAMP request ID of this request.
:type request: int
:param procedure: The WAMP or application URI of the RPC endpoint provided.
:type procedure: str
:param match: The procedure matching policy to be used for the registration.
:type match: str
:param invoke: The procedure invocation policy to be use... | def __init__(self, request, procedure, match=None, invoke=None, concurrency=None, force_reregister=None):
| assert (type(request) in six.integer_types)
assert (type(procedure) == six.text_type)
assert ((match is None) or (type(match) == six.text_type))
assert ((match is None) or (match in [Register.MATCH_EXACT, Register.MATCH_PREFIX, Register.MATCH_WILDCARD]))
assert ((invoke is None) or (type(invoke) == ... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Register.MESSAGE_TYPE))
if (len(wmsg) != 4):
raise ProtocolError('invalid message length {0} for REGISTER'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in REGISTER")
options = check_or_raise_extra(wmsg[2], u"'opt... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Register.MESSAGE_TYPE, self.request, self.marshal_options(), self.procedure]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Register(request={0}, procedure={1}, match={2}, invoke={3}, concurrency={4}, force_reregister={5})'.format(self.request, self.procedure, self.match, self.invoke, self.concurrency, self.force_reregister)
|
':param request: The request ID of the original ``REGISTER`` request.
:type request: int
:param registration: The registration ID for the registered procedure (or procedure pattern).
:type registration: int'
| def __init__(self, request, registration):
| assert (type(request) in six.integer_types)
assert (type(registration) in six.integer_types)
Message.__init__(self)
self.request = request
self.registration = registration
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Registered.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for REGISTERED'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in REGISTERED")
registration = check_or_raise_id(wmsg[2]... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Registered.MESSAGE_TYPE, self.request, self.registration]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Registered(request={0}, registration={1})'.format(self.request, self.registration)
|
':param request: The WAMP request ID of this request.
:type request: int
:param registration: The registration ID for the registration to unregister.
:type registration: int'
| def __init__(self, request, registration):
| assert (type(request) in six.integer_types)
assert (type(registration) in six.integer_types)
Message.__init__(self)
self.request = request
self.registration = registration
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Unregister.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for WAMP UNREGISTER'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in UNREGISTER")
registration = check_or_raise_id... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| return [Unregister.MESSAGE_TYPE, self.request, self.registration]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Unregister(request={0}, registration={1})'.format(self.request, self.registration)
|
':param request: The request ID of the original ``UNREGISTER`` request.
:type request: int
:param registration: If unregister was actively triggered by router, the ID
of the registration revoked.
:type registration: int or None
:param reason: The reason (an URI) for revocation.
:type reason: str or None.'
| def __init__(self, request, registration=None, reason=None):
| assert (type(request) in six.integer_types)
assert ((registration is None) or (type(registration) in six.integer_types))
assert ((reason is None) or (type(reason) == six.text_type))
assert (((request != 0) and (registration is None)) or ((request == 0) and (registration != 0)))
Message.__init__(self... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Unregistered.MESSAGE_TYPE))
if (len(wmsg) not in [2, 3]):
raise ProtocolError('invalid message length {0} for UNREGISTERED'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in UNREGISTERED")
registration = None
r... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| if ((self.reason is not None) or (self.registration is not None)):
details = {}
if (self.reason is not None):
details[u'reason'] = self.reason
if (self.registration is not None):
details[u'registration'] = self.registration
return [Unregistered.MESSAGE_TYPE, s... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Unregistered(request={0}, reason={1}, registration={2})'.format(self.request, self.reason, self.registration)
|
':param request: The WAMP request ID of this request.
:type request: int
:param registration: The registration ID of the endpoint to be invoked.
:type registration: int
:param args: Positional values for application-defined event payload.
Must be serializable using any serializers in use.
:type args: list or tuple or N... | def __init__(self, request, registration, args=None, kwargs=None, payload=None, timeout=None, receive_progress=None, caller=None, caller_authid=None, caller_authrole=None, procedure=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(request) in six.integer_types)
assert (type(registration) in six.integer_types)
assert ((args is None) or (type(args) in [list, tuple]))
assert ((kwargs is None) or (type(kwargs) == dict))
assert ((payload is None) or (type(payload) == six.binary_type))
assert ((payload is None) or ... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Invocation.MESSAGE_TYPE))
if (len(wmsg) not in (4, 5, 6)):
raise ProtocolError('invalid message length {0} for INVOCATION'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in INVOCATION")
registration = check_or_rais... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| options = {}
if (self.timeout is not None):
options[u'timeout'] = self.timeout
if (self.receive_progress is not None):
options[u'receive_progress'] = self.receive_progress
if (self.caller is not None):
options[u'caller'] = self.caller
if (self.caller_authid is not None):
... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Invocation(request={0}, registration={1}, args={2}, kwargs={3}, timeout={4}, receive_progress={5}, caller={6}, caller_authid={7}, caller_authrole={8}, procedure={9}, enc_algo={10}, enc_key={11}, enc_serializer={12}, payload={13})'.format(self.request, self.registratio... |
':param request: The WAMP request ID of the original ``INVOCATION`` to interrupt.
:type request: int
:param mode: Specifies how to interrupt the invocation (``"abort"`` or ``"kill"``).
:type mode: str or None'
| def __init__(self, request, mode=None):
| assert (type(request) in six.integer_types)
assert ((mode is None) or (type(mode) == six.text_type))
assert ((mode is None) or (mode in [self.ABORT, self.KILL]))
Message.__init__(self)
self.request = request
self.mode = mode
|
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Interrupt.MESSAGE_TYPE))
if (len(wmsg) != 3):
raise ProtocolError('invalid message length {0} for INTERRUPT'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in INTERRUPT")
options = check_or_raise_extra(wmsg[2], u"'... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| options = {}
if (self.mode is not None):
options[u'mode'] = self.mode
return [Interrupt.MESSAGE_TYPE, self.request, options]
|
'Returns string representation of this message.'
| def __str__(self):
| return u'Interrupt(request={0}, mode={1})'.format(self.request, self.mode)
|
':param request: The WAMP request ID of the original call.
:type request: int
:param args: Positional values for application-defined event payload.
Must be serializable using any serializers in use.
:type args: list or tuple or None
:param kwargs: Keyword values for application-defined event payload.
Must be serializab... | def __init__(self, request, args=None, kwargs=None, payload=None, progress=None, enc_algo=None, enc_key=None, enc_serializer=None):
| assert (type(request) in six.integer_types)
assert ((args is None) or (type(args) in [list, tuple]))
assert ((kwargs is None) or (type(kwargs) == dict))
assert ((payload is None) or (type(payload) == six.binary_type))
assert ((payload is None) or ((payload is not None) and (args is None) and (kwargs... |
'Verifies and parses an unserialized raw message into an actual WAMP message instance.
:param wmsg: The unserialized raw message.
:type wmsg: list
:returns: An instance of this class.'
| @staticmethod
def parse(wmsg):
| assert ((len(wmsg) > 0) and (wmsg[0] == Yield.MESSAGE_TYPE))
if (len(wmsg) not in (3, 4, 5)):
raise ProtocolError('invalid message length {0} for YIELD'.format(len(wmsg)))
request = check_or_raise_id(wmsg[1], u"'request' in YIELD")
options = check_or_raise_extra(wmsg[2], u"'... |
'Marshal this object into a raw message for subsequent serialization to bytes.
:returns: The serialized raw message.
:rtype: list'
| def marshal(self):
| options = {}
if (self.progress is not None):
options[u'progress'] = self.progress
if self.payload:
if (self.enc_algo is not None):
options[u'enc_algo'] = self.enc_algo
if (self.enc_key is not None):
options[u'enc_key'] = self.enc_key
if (self.enc_seria... |
'Returns string representation of this message.'
| def __str__(self):
| return u'Yield(request={0}, args={1}, kwargs={2}, progress={3}, enc_algo={4}, enc_key={5}, enc_serializer={6}, payload={7})'.format(self.request, self.args, self.kwargs, self.progress, self.enc_algo, self.enc_key, self.enc_serializer, b2a(self.payload))
|
':param uri: The URI or URI pattern, e.g. ``"com.myapp.product.<product:int>.update"``.
:type uri: str
:param target: The target for this pattern: a procedure endpoint (a callable),
an event handler (a callable) or an exception (a class).
:type target: callable or obj
:param options: An optional options object
:type op... | def __init__(self, uri, target, options=None):
| assert (type(uri) == six.text_type)
assert (len(uri) > 0)
assert (target in [Pattern.URI_TARGET_ENDPOINT, Pattern.URI_TARGET_HANDLER, Pattern.URI_TARGET_EXCEPTION])
if (target == Pattern.URI_TARGET_ENDPOINT):
assert ((options is None) or (type(options) == RegisterOptions))
elif (target == Pa... |
'Returns the Options instance (if present) for this pattern.
:return: None or the Options instance
:rtype: None or RegisterOptions or SubscribeOptions'
| @public
@property
def options(self):
| return self._options
|
'Returns the URI type of this pattern
:return:
:rtype: Pattern.URI_TYPE_EXACT, Pattern.URI_TYPE_PREFIX or Pattern.URI_TYPE_WILDCARD'
| @public
@property
def uri_type(self):
| return self._type
|
'Returns the original URI (pattern) for this pattern.
:returns: The URI (pattern), e.g. ``"com.myapp.product.<product:int>.update"``.
:rtype: str'
| @public
def uri(self):
| return self._uri
|
'Match the given (fully qualified) URI according to this pattern
and return extracted args and kwargs.
:param uri: The URI to match, e.g. ``"com.myapp.product.123456.update"``.
:type uri: str
:returns: A tuple ``(args, kwargs)``
:rtype: tuple'
| def match(self, uri):
| args = []
kwargs = {}
if (self._type == Pattern.URI_TYPE_EXACT):
return (args, kwargs)
elif (self._type == Pattern.URI_TYPE_WILDCARD):
match = self._pattern.match(uri)
if match:
for key in self._names:
val = match.group(key)
val = self.... |
'Check if this pattern is for a procedure endpoint.
:returns: ``True``, iff this pattern is for a procedure endpoint.
:rtype: bool'
| @public
def is_endpoint(self):
| return (self._target == Pattern.URI_TARGET_ENDPOINT)
|
'Check if this pattern is for an event handler.
:returns: ``True``, iff this pattern is for an event handler.
:rtype: bool'
| @public
def is_handler(self):
| return (self._target == Pattern.URI_TARGET_HANDLER)
|
'Check if this pattern is for an exception.
:returns: ``True``, iff this pattern is for an exception.
:rtype: bool'
| @public
def is_exception(self):
| return (self._target == Pattern.URI_TARGET_EXCEPTION)
|
':param realm: The realm the session would like to join or ``None`` to let the router
auto-decide the realm (if the router is configured and allowing to do so).
:type realm: str
:param extra: Optional user-supplied object with extra configuration.
This can be any object you like, and is accessible in your
`ApplicationS... | def __init__(self, realm=None, extra=None, keyring=None, controller=None, shared=None):
| assert ((realm is None) or (type(realm) == six.text_type))
self.realm = realm
self.extra = extra
self.keyring = keyring
self.controller = controller
self.shared = shared
|
':param realm: The realm the client is joined to.
:type realm: str
:param authid: The authentication ID the client is assigned, e.g. ``"joe"`` or ``"joe@example.com"``.
:type authid: str
:param authrole: The authentication role the client is assigned, e.g. ``"anonymous"``, ``"user"`` or ``"com.myapp.user"``.
:type auth... | def __init__(self, realm=None, authid=None, authrole=None, authmethod=None, authprovider=None, authextra=None):
| assert ((realm is None) or (type(realm) == six.text_type))
assert ((authid is None) or (type(authid) == six.text_type))
assert ((authrole is None) or (type(authrole) == six.text_type))
assert ((authmethod is None) or (type(authmethod) == six.text_type))
assert ((authprovider is None) or (type(authpr... |
':param reason: The reason of denying the authentication (an URI, e.g. ``u\'wamp.error.not_authorized\'``)
:type reason: str
:param message: A human readable message (for logging purposes).
:type message: str'
| def __init__(self, reason=u'wamp.error.not_authorized', message=None):
| assert (type(reason) == six.text_type)
assert ((message is None) or (type(message) == six.text_type))
self.reason = reason
self.message = message
|
':param method: The authentication method for the challenge (e.g. ``"wampcra"``).
:type method: str
:param extra: Any extra information for the authentication challenge. This is
specific to the authentication method.
:type extra: dict'
| def __init__(self, method, extra=None):
| assert (type(method) == six.text_type)
assert ((extra is None) or (type(extra) == dict))
self.method = method
self.extra = (extra or {})
|
':param realm: The realm the client wants to join.
:type realm: str or None
:param authmethods: The authentication methods the client is willing to perform.
:type authmethods: list of str or None
:param authid: The authid the client wants to authenticate as.
:type authid: str or None
:param authrole: The authrole the c... | def __init__(self, realm=None, authmethods=None, authid=None, authrole=None, authextra=None, session_roles=None, pending_session=None, resumable=None, resume_session=None, resume_token=None):
| assert ((realm is None) or (type(realm) == six.text_type))
assert ((authmethods is None) or ((type(authmethods) == list) and all(((type(x) == six.text_type) for x in authmethods))))
assert ((authid is None) or (type(authid) == six.text_type))
assert ((authrole is None) or (type(authrole) == six.text_typ... |
':param realm: The realm this WAMP session is attached to.
:type realm: str
:param session: WAMP session ID of this session.
:type session: int
:param resumed: Whether the session is a resumed one.
:type resumed: bool or None
:param resumable: Whether this session can be resumed later.
:type resumable: bool or None
:pa... | def __init__(self, realm, session, authid=None, authrole=None, authmethod=None, authprovider=None, authextra=None, resumed=None, resumable=None, resume_token=None):
| assert (type(realm) == six.text_type)
assert (type(session) in six.integer_types)
assert ((authid is None) or (type(authid) == six.text_type))
assert ((authrole is None) or (type(authrole) == six.text_type))
assert ((authmethod is None) or (type(authmethod) == six.text_type))
assert ((authprovid... |
':param reason: The close reason (an URI, e.g. ``wamp.close.normal``)
:type reason: str
:param message: Closing log message.
:type message: str'
| def __init__(self, reason=None, message=None):
| assert ((reason is None) or (type(reason) == six.text_type))
assert ((message is None) or (type(message) == six.text_type))
self.reason = reason
self.message = message
|
':param match: The topic matching method to be used for the subscription.
:type match: str
:param details: When invoking the handler, provide event details in a keyword
parameter ``details``.
:type details: bool
:param details_arg: DEPCREATED (use "details" flag). When invoking the handler
provide event details in this... | def __init__(self, match=None, details=None, details_arg=None, get_retained=None):
| assert ((match is None) or ((type(match) == six.text_type) and (match in [u'exact', u'prefix', u'wildcard'])))
assert ((details is None) or ((type(details) == bool) and (details_arg is None)))
assert ((details_arg is None) or (type(details_arg) == str))
assert ((get_retained is None) or (type(get_retain... |
'Returns options dict as sent within WAMP messages.'
| def message_attr(self):
| options = {}
if (self.match is not None):
options[u'match'] = self.match
if (self.get_retained is not None):
options[u'get_retained'] = self.get_retained
return options
|
':param subscription: The (client side) subscription object on which this event is delivered.
:type subscription: instance of :class:`autobahn.wamp.request.Subscription`
:param publication: The publication ID of the event (always present).
:type publication: int
:param publisher: The WAMP session ID of the original pub... | def __init__(self, subscription, publication, publisher=None, publisher_authid=None, publisher_authrole=None, topic=None, retained=None, enc_algo=None):
| assert isinstance(subscription, Subscription)
assert (type(publication) in six.integer_types)
assert ((publisher is None) or (type(publisher) in six.integer_types))
assert ((publisher_authid is None) or (type(publisher_authid) == six.text_type))
assert ((publisher_authrole is None) or (type(publishe... |
':param acknowledge: If ``True``, acknowledge the publication with a success or
error response.
:type acknowledge: bool
:param exclude_me: If ``True``, exclude the publisher from receiving the event, even
if he is subscribed (and eligible).
:type exclude_me: bool or None
:param exclude: A single WAMP session ID or a li... | def __init__(self, acknowledge=None, exclude_me=None, exclude=None, exclude_authid=None, exclude_authrole=None, eligible=None, eligible_authid=None, eligible_authrole=None, retain=None):
| assert ((acknowledge is None) or (type(acknowledge) == bool))
assert ((exclude_me is None) or (type(exclude_me) == bool))
assert ((exclude is None) or (type(exclude) in six.integer_types) or ((type(exclude) == list) and all(((type(x) in six.integer_types) for x in exclude))))
assert ((exclude_authid is ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.