diff --git a/compile_definitions.py b/compile_definitions.py
index 2cefe727a47aff38b649e7a290202716134fa9ba..57ff6e90f00719ff7b1c0a2594dd65fa2e7ed429 100644
--- a/compile_definitions.py
+++ b/compile_definitions.py
@@ -2,7 +2,6 @@ from __future__ import division
import collections
import struct
-import subprocess
from xml.etree import ElementTree
import math
@@ -385,7 +384,20 @@ Field = collections.namedtuple('Field', ('name', 'type', 'basic_type', 'reserved
line('''\nclass %s(AMQPMethodPayload):
"""
%s
- """
+''', full_class_name, to_docstring(method.label, method.docs))
+
+ for field in non_reserved_fields:
+ if (field.label is not None) or (field.docs is not None):
+ line(' :param %s: %s\n',
+ format_field_name(field.name),
+ to_docstring(field.label, field.docs, prefix=12,
+ blank=False))
+
+ line(' :type %s: %s (%s in AMQP)\n',
+ format_field_name(field.name),
+ TYPE_TRANSLATOR[field.basic_type], field.type)
+
+ line(''' """
__slots__ = (%s)
NAME = %s
@@ -398,9 +410,6 @@ Field = collections.namedtuple('Field', ('name', 'type', 'basic_type', 'reserved
IS_SIZE_STATIC = %s # this means that argument part has always the same length
IS_CONTENT_STATIC = %s # this means that argument part has always the same content
''',
-
- full_class_name,
- to_docstring(method.label, method.docs),
slots,
frepr(cls.name + '.' + method.name),
frepr(cls.index), frepr(method.index),
@@ -446,44 +455,32 @@ Field = collections.namedtuple('Field', ('name', 'type', 'basic_type', 'reserved
line('''\n def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return '%s(%S)' % (', '.join(map(repr, [%s])))\n''',
+ return '%s(%S)' % (', '.join(map(repr, [%s])))''',
full_class_name,
u", ".join(['self.'+format_field_name(field.name) for field in non_reserved_fields]))
- # constructor
- line('''\n def __init__(%s):
+ if len(non_reserved_fields) > 0:
+
+ # constructor
+ line('''\n\n def __init__(%s):
"""
Create frame %s
+ """
''',
- u', '.join(
- ['self'] + [format_field_name(field.name) for field in
- non_reserved_fields]),
- cls.name + '.' + method.name,
- )
-
- if len(non_reserved_fields) > 0:
- line('\n')
-
- for field in non_reserved_fields:
- if (field.label is not None) or (field.docs is not None):
- line(' :param %s: %s\n',
- format_field_name(field.name),
- to_docstring(field.label, field.docs, prefix=12,
- blank=False))
+ u', '.join(
+ ['self'] + [format_field_name(field.name) for field in
+ non_reserved_fields]),
+ cls.name + '.' + method.name,
+ )
- line(' :type %s: %s (%s in AMQP)\n',
- format_field_name(field.name),
- TYPE_TRANSLATOR[field.basic_type], field.type)
-
- line(' """\n')
+ for field in non_reserved_fields:
+ line(' self.%s = %s\n', format_field_name(field.name),
+ format_field_name(field.name))
- for field in non_reserved_fields:
- line(' self.%s = %s\n', format_field_name(field.name),
- format_field_name(field.name))
-
- if len(non_reserved_fields) == 0:
+ elif len(non_reserved_fields) == 0:
line('\n')
# end
@@ -496,16 +493,15 @@ Field = collections.namedtuple('Field', ('name', 'type', 'basic_type', 'reserved
line(' def get_size(self): # type: () -> int\n')
line(get_counter(method.fields, 'self.', 2))
- line('''\n @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> %s
+ line('''\n @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> %s
offset = start_offset
''', full_class_name)
line(get_from_buffer(method.fields, '', 2,
remark=(method.name == 'deliver')))
- line(" return %s(%s)",
- full_class_name,
+ line(" return cls(%s)",
u', '.join(
format_field_name(field.name) for field in method.fields if
not field.reserved))
@@ -557,6 +553,6 @@ REPLIES_FOR = {\n''')
if __name__ == '__main__':
compile_definitions()
- proc = subprocess.run(['yapf', 'coolamqp/framing/definitions.py'], stdout=subprocess.PIPE)
- with open('coolamqp/framing/definitions.py', 'wb') as f_out:
- f_out.write(proc.stdout)
+ # proc = subprocess.run(['yapf', 'coolamqp/framing/definitions.py'], stdout=subprocess.PIPE)
+ # with open('coolamqp/framing/definitions.py', 'wb') as f_out:
+ # f_out.write(proc.stdout)
diff --git a/coolamqp/framing/base.py b/coolamqp/framing/base.py
index e52f7be306ca3aec9a7bd0d31878e20c0891ee45..d9dbc34e10cd23dfa80e29759ede73cdb8aee615 100644
--- a/coolamqp/framing/base.py
+++ b/coolamqp/framing/base.py
@@ -163,7 +163,7 @@ class AMQPMethodPayload(AMQPPayload):
return len(
self.STATIC_CONTENT) - 4 - 4 - 1 # minus length, class, method, frame_end
- raise NotImplementedError()
+ raise RuntimeError('Should never be executed!')
def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
"""
diff --git a/coolamqp/framing/definitions.py b/coolamqp/framing/definitions.py
index 94f561672ff44620056d6330b1e4c33e87250a77..9049e2d3f857c6f117f500c80468f6b03147b464 100644
--- a/coolamqp/framing/definitions.py
+++ b/coolamqp/framing/definitions.py
@@ -35,8 +35,7 @@ from coolamqp.framing.compilation.content_property import compile_particular_con
logger = logging.getLogger(__name__)
-Field = collections.namedtuple('Field',
- ('name', 'type', 'basic_type', 'reserved'))
+Field = collections.namedtuple('Field', ('name', 'type', 'basic_type', 'reserved'))
# Core constants
FRAME_METHOD = 1
@@ -152,15 +151,12 @@ NOT_IMPLEMENTED = 540
# normal operations.
INTERNAL_ERROR = 541
-HARD_ERRORS = [
- CONNECTION_FORCED, INVALID_PATH, FRAME_ERROR, SYNTAX_ERROR,
- COMMAND_INVALID, CHANNEL_ERROR, UNEXPECTED_FRAME, RESOURCE_ERROR,
- NOT_ALLOWED, NOT_IMPLEMENTED, INTERNAL_ERROR
-]
-SOFT_ERRORS = [
- CONTENT_TOO_LARGE, NO_CONSUMERS, ACCESS_REFUSED, NOT_FOUND,
- RESOURCE_LOCKED, PRECONDITION_FAILED
-]
+SOFT_ERRORS = [CONTENT_TOO_LARGE, NO_CONSUMERS, ACCESS_REFUSED, NOT_FOUND, RESOURCE_LOCKED,
+ PRECONDITION_FAILED]
+HARD_ERRORS = [CONNECTION_FORCED, INVALID_PATH, FRAME_ERROR, SYNTAX_ERROR, COMMAND_INVALID,
+ CHANNEL_ERROR, UNEXPECTED_FRAME, RESOURCE_ERROR, NOT_ALLOWED, NOT_IMPLEMENTED,
+ INTERNAL_ERROR]
+
DOMAIN_TO_BASIC_TYPE = {
u'class-id': u'short',
@@ -189,7 +185,6 @@ DOMAIN_TO_BASIC_TYPE = {
u'table': None,
}
-
class Connection(AMQPClass):
"""
The connection class provides methods for a client to establish a
@@ -206,6 +201,7 @@ class ConnectionBlocked(AMQPMethodPayload):
This method indicates that a connection has been blocked
and does not accept new publishes.
+ :type reason: binary type (max length 255) (shortstr in AMQP)
"""
__slots__ = (u'reason', )
@@ -220,13 +216,14 @@ class ConnectionBlocked(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reason', u'shortstr', u'shortstr', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConnectionBlocked(%s)' % (', '.join(map(repr, [self.reason])))
@@ -234,8 +231,6 @@ class ConnectionBlocked(AMQPMethodPayload):
def __init__(self, reason):
"""
Create frame connection.blocked
-
- :type reason: binary type (max length 255) (shortstr in AMQP)
"""
self.reason = reason
@@ -246,15 +241,14 @@ class ConnectionBlocked(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1 + len(self.reason)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionBlocked
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionBlocked
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
reason = buf[offset:offset + s_len]
offset += s_len
- return ConnectionBlocked(reason)
+ return cls(reason)
class ConnectionClose(AMQPMethodPayload):
@@ -269,13 +263,19 @@ class ConnectionClose(AMQPMethodPayload):
exception, the
sender provides the class and method id of the method which
caused the exception.
+ :type reply_code: int, 16 bit unsigned (reply-code in AMQP)
+ :type reply_text: binary type (max length 255) (reply-text in AMQP)
+ :param class_id: Failing method class
+ When the close is provoked by a method exception, this is
+ the class of the
+ method.
+ :type class_id: int, 16 bit unsigned (class-id in AMQP)
+ :param method_id: Failing method id
+ When the close is provoked by a method exception, this is
+ the ID of the method.
+ :type method_id: int, 16 bit unsigned (method-id in AMQP)
"""
- __slots__ = (
- u'reply_code',
- u'reply_text',
- u'class_id',
- u'method_id',
- )
+ __slots__ = (u'reply_code', u'reply_text', u'class_id', u'method_id',)
NAME = u'connection.close'
@@ -288,7 +288,7 @@ class ConnectionClose(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reply-code', u'reply-code', u'short', reserved=False),
Field(u'reply-text', u'reply-text', u'shortstr', reserved=False),
Field(u'class-id', u'class-id', u'short', reserved=False),
@@ -298,28 +298,15 @@ class ConnectionClose(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionClose(%s)' % (', '.join(
- map(repr, [
- self.reply_code, self.reply_text, self.class_id, self.method_id
- ])))
+ return 'ConnectionClose(%s)' % (
+ ', '.join(map(repr, [self.reply_code, self.reply_text, self.class_id, self.method_id])))
def __init__(self, reply_code, reply_text, class_id, method_id):
"""
Create frame connection.close
-
- :type reply_code: int, 16 bit unsigned (reply-code in AMQP)
- :type reply_text: binary type (max length 255) (reply-text in AMQP)
- :param class_id: Failing method class
- When the close is provoked by a method exception, this is
- the class of the
- method.
- :type class_id: int, 16 bit unsigned (class-id in AMQP)
- :param method_id: Failing method id
- When the close is provoked by a method exception, this is
- the ID of the method.
- :type method_id: int, 16 bit unsigned (method-id in AMQP)
"""
self.reply_code = reply_code
self.reply_text = reply_text
@@ -334,9 +321,8 @@ class ConnectionClose(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 7 + len(self.reply_text)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionClose
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionClose
offset = start_offset
reply_code, s_len, = struct.unpack_from('!HB', buf, offset)
offset += 3
@@ -344,7 +330,7 @@ class ConnectionClose(AMQPMethodPayload):
offset += s_len
class_id, method_id, = struct.unpack_from('!HH', buf, offset)
offset += 4
- return ConnectionClose(reply_code, reply_text, class_id, method_id)
+ return cls(reply_code, reply_text, class_id, method_id)
class ConnectionCloseOk(AMQPMethodPayload):
@@ -372,20 +358,15 @@ class ConnectionCloseOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConnectionCloseOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame connection.close-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionCloseOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionCloseOk
offset = start_offset
- return ConnectionCloseOk()
+ return cls()
class ConnectionOpen(AMQPMethodPayload):
@@ -400,6 +381,9 @@ class ConnectionOpen(AMQPMethodPayload):
the number
of each type of entity that may be used, per connection and/or
in total.
+ :param virtual_host: Virtual host name
+ The name of the virtual host to work with.
+ :type virtual_host: binary type (max length 255) (path in AMQP)
"""
__slots__ = (u'virtual_host', )
@@ -414,7 +398,7 @@ class ConnectionOpen(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'virtual-host', u'path', u'shortstr', reserved=False),
Field(u'reserved-1', u'shortstr', u'shortstr', reserved=True),
Field(u'reserved-2', u'bit', u'bit', reserved=True),
@@ -423,18 +407,14 @@ class ConnectionOpen(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionOpen(%s)' % (', '.join(map(repr,
- [self.virtual_host])))
+ return 'ConnectionOpen(%s)' % (', '.join(map(repr, [self.virtual_host])))
def __init__(self, virtual_host):
"""
Create frame connection.open
-
- :param virtual_host: Virtual host name
- The name of the virtual host to work with.
- :type virtual_host: binary type (max length 255) (path in AMQP)
"""
self.virtual_host = virtual_host
@@ -447,9 +427,8 @@ class ConnectionOpen(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 3 + len(self.virtual_host)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionOpen
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionOpen
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
@@ -459,7 +438,7 @@ class ConnectionOpen(AMQPMethodPayload):
offset += 1
offset += s_len # reserved field!
offset += 1
- return ConnectionOpen(virtual_host)
+ return cls(virtual_host)
class ConnectionOpenOk(AMQPMethodPayload):
@@ -483,30 +462,25 @@ class ConnectionOpenOk(AMQPMethodPayload):
STATIC_CONTENT = b'\x00\x00\x00\x04\x00\x0A\x00\x29\x00\xCE' # spans LENGTH, CLASS ID, METHOD ID, ....., FRAME_END
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'shortstr', u'shortstr', reserved=True),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConnectionOpenOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame connection.open-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionOpenOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionOpenOk
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
offset += s_len # reserved field!
- return ConnectionOpenOk()
+ return cls()
class ConnectionStart(AMQPMethodPayload):
@@ -518,14 +492,40 @@ class ConnectionStart(AMQPMethodPayload):
protocol version that the server proposes, along with a list of
security mechanisms
which the client can use for authentication.
+ :param version_major: Protocol major version
+ The major version number can take any value from 0 to 99 as
+ defined in the
+ AMQP specification.
+ :type version_major: int, 8 bit unsigned (octet in AMQP)
+ :param version_minor: Protocol minor version
+ The minor version number can take any value from 0 to 99 as
+ defined in the
+ AMQP specification.
+ :type version_minor: int, 8 bit unsigned (octet in AMQP)
+ :param server_properties: Server properties
+ The properties SHOULD contain at least these fields:
+ "host", specifying the
+ server host name or address, "product", giving the name
+ of the server product,
+ "version", giving the name of the server version,
+ "platform", giving the name
+ of the operating system, "copyright", if appropriate,
+ and "information", giving
+ other general information.
+ :type server_properties: table. See coolamqp.uplink.framing.field_table (peer-properties in AMQP)
+ :param mechanisms: Available security mechanisms
+ A list of the security mechanisms that the server supports,
+ delimited by spaces.
+ :type mechanisms: binary type (longstr in AMQP)
+ :param locales: Available message locales
+ A list of the message locales that the server supports,
+ delimited by spaces. The
+ locale defines the language in which the server will send
+ reply texts.
+ :type locales: binary type (longstr in AMQP)
"""
__slots__ = (
- u'version_major',
- u'version_minor',
- u'server_properties',
- u'mechanisms',
- u'locales',
- )
+ u'version_major', u'version_minor', u'server_properties', u'mechanisms', u'locales',)
NAME = u'connection.start'
@@ -541,10 +541,7 @@ class ConnectionStart(AMQPMethodPayload):
FIELDS = [
Field(u'version-major', u'octet', u'octet', reserved=False),
Field(u'version-minor', u'octet', u'octet', reserved=False),
- Field(u'server-properties',
- u'peer-properties',
- u'table',
- reserved=False),
+ Field(u'server-properties', u'peer-properties', u'table', reserved=False),
Field(u'mechanisms', u'longstr', u'longstr', reserved=False),
Field(u'locales', u'longstr', u'longstr', reserved=False),
]
@@ -552,50 +549,16 @@ class ConnectionStart(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionStart(%s)' % (', '.join(
- map(repr, [
- self.version_major, self.version_minor, self.server_properties,
- self.mechanisms, self.locales
- ])))
+ return 'ConnectionStart(%s)' % (', '.join(map(repr, [self.version_major, self.version_minor,
+ self.server_properties,
+ self.mechanisms, self.locales])))
- def __init__(self, version_major, version_minor, server_properties,
- mechanisms, locales):
+ def __init__(self, version_major, version_minor, server_properties, mechanisms, locales):
"""
Create frame connection.start
-
- :param version_major: Protocol major version
- The major version number can take any value from 0 to 99 as
- defined in the
- AMQP specification.
- :type version_major: int, 8 bit unsigned (octet in AMQP)
- :param version_minor: Protocol minor version
- The minor version number can take any value from 0 to 99 as
- defined in the
- AMQP specification.
- :type version_minor: int, 8 bit unsigned (octet in AMQP)
- :param server_properties: Server properties
- The properties SHOULD contain at least these fields:
- "host", specifying the
- server host name or address, "product", giving the name
- of the server product,
- "version", giving the name of the server version,
- "platform", giving the name
- of the operating system, "copyright", if appropriate,
- and "information", giving
- other general information.
- :type server_properties: table. See coolamqp.uplink.framing.field_table (peer-properties in AMQP)
- :param mechanisms: Available security mechanisms
- A list of the security mechanisms that the server supports,
- delimited by spaces.
- :type mechanisms: binary type (longstr in AMQP)
- :param locales: Available message locales
- A list of the message locales that the server supports,
- delimited by spaces. The
- locale defines the language in which the server will send
- reply texts.
- :type locales: binary type (longstr in AMQP)
"""
self.version_major = version_major
self.version_minor = version_minor
@@ -612,12 +575,11 @@ class ConnectionStart(AMQPMethodPayload):
buf.write(self.locales)
def get_size(self): # type: () -> int
- return 10 + frame_table_size(self.server_properties) + len(
- self.mechanisms) + len(self.locales)
+ return 10 + frame_table_size(self.server_properties) + len(self.mechanisms) + len(
+ self.locales)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionStart
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionStart
offset = start_offset
version_major, version_minor, = struct.unpack_from('!BB', buf, offset)
offset += 2
@@ -631,8 +593,7 @@ class ConnectionStart(AMQPMethodPayload):
offset += 4
locales = buf[offset:offset + s_len]
offset += s_len
- return ConnectionStart(version_major, version_minor, server_properties,
- mechanisms, locales)
+ return cls(version_major, version_minor, server_properties, mechanisms, locales)
class ConnectionSecure(AMQPMethodPayload):
@@ -644,6 +605,11 @@ class ConnectionSecure(AMQPMethodPayload):
received sufficient information to authenticate each other. This
method challenges
the client to provide more information.
+ :param challenge: Security challenge data
+ Challenge information, a block of opaque binary data passed
+ to the security
+ mechanism.
+ :type challenge: binary type (longstr in AMQP)
"""
__slots__ = (u'challenge', )
@@ -658,27 +624,21 @@ class ConnectionSecure(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'challenge', u'longstr', u'longstr', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionSecure(%s)' % (', '.join(map(repr,
- [self.challenge])))
+ return 'ConnectionSecure(%s)' % (', '.join(map(repr, [self.challenge])))
def __init__(self, challenge):
"""
Create frame connection.secure
-
- :param challenge: Security challenge data
- Challenge information, a block of opaque binary data passed
- to the security
- mechanism.
- :type challenge: binary type (longstr in AMQP)
"""
self.challenge = challenge
@@ -689,15 +649,14 @@ class ConnectionSecure(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 4 + len(self.challenge)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionSecure
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionSecure
offset = start_offset
s_len, = struct.unpack_from('!L', buf, offset)
offset += 4
challenge = buf[offset:offset + s_len]
offset += s_len
- return ConnectionSecure(challenge)
+ return cls(challenge)
class ConnectionStartOk(AMQPMethodPayload):
@@ -705,13 +664,32 @@ class ConnectionStartOk(AMQPMethodPayload):
Select security mechanism and locale
This method selects a SASL security mechanism.
+ :param client_properties: Client properties
+ The properties SHOULD contain at least these fields:
+ "product", giving the name
+ of the client product, "version", giving the name of the
+ client version, "platform",
+ giving the name of the operating system, "copyright", if
+ appropriate, and
+ "information", giving other general information.
+ :type client_properties: table. See coolamqp.uplink.framing.field_table (peer-properties in AMQP)
+ :param mechanism: Selected security mechanism
+ A single security mechanisms selected by the client, which
+ must be one of those
+ specified by the server.
+ :type mechanism: binary type (max length 255) (shortstr in AMQP)
+ :param response: Security response data
+ A block of opaque data passed to the security mechanism. The
+ contents of this
+ data are defined by the SASL security mechanism.
+ :type response: binary type (longstr in AMQP)
+ :param locale: Selected message locale
+ A single message locale selected by the client, which must
+ be one of those
+ specified by the server.
+ :type locale: binary type (max length 255) (shortstr in AMQP)
"""
- __slots__ = (
- u'client_properties',
- u'mechanism',
- u'response',
- u'locale',
- )
+ __slots__ = (u'client_properties', u'mechanism', u'response', u'locale',)
NAME = u'connection.start-ok'
@@ -725,10 +703,7 @@ class ConnectionStartOk(AMQPMethodPayload):
# See constructor pydoc for details
FIELDS = [
- Field(u'client-properties',
- u'peer-properties',
- u'table',
- reserved=False),
+ Field(u'client-properties', u'peer-properties', u'table', reserved=False),
Field(u'mechanism', u'shortstr', u'shortstr', reserved=False),
Field(u'response', u'longstr', u'longstr', reserved=False),
Field(u'locale', u'shortstr', u'shortstr', reserved=False),
@@ -737,42 +712,15 @@ class ConnectionStartOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConnectionStartOk(%s)' % (', '.join(
- map(repr, [
- self.client_properties, self.mechanism, self.response,
- self.locale
- ])))
+ map(repr, [self.client_properties, self.mechanism, self.response, self.locale])))
def __init__(self, client_properties, mechanism, response, locale):
"""
Create frame connection.start-ok
-
- :param client_properties: Client properties
- The properties SHOULD contain at least these fields:
- "product", giving the name
- of the client product, "version", giving the name of the
- client version, "platform",
- giving the name of the operating system, "copyright", if
- appropriate, and
- "information", giving other general information.
- :type client_properties: table. See coolamqp.uplink.framing.field_table (peer-properties in AMQP)
- :param mechanism: Selected security mechanism
- A single security mechanisms selected by the client, which
- must be one of those
- specified by the server.
- :type mechanism: binary type (max length 255) (shortstr in AMQP)
- :param response: Security response data
- A block of opaque data passed to the security mechanism. The
- contents of this
- data are defined by the SASL security mechanism.
- :type response: binary type (longstr in AMQP)
- :param locale: Selected message locale
- A single message locale selected by the client, which must
- be one of those
- specified by the server.
- :type locale: binary type (max length 255) (shortstr in AMQP)
"""
self.client_properties = client_properties
self.mechanism = mechanism
@@ -789,12 +737,11 @@ class ConnectionStartOk(AMQPMethodPayload):
buf.write(self.locale)
def get_size(self): # type: () -> int
- return 6 + frame_table_size(self.client_properties) + len(
- self.mechanism) + len(self.response) + len(self.locale)
+ return 6 + frame_table_size(self.client_properties) + len(self.mechanism) + len(
+ self.response) + len(self.locale)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionStartOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionStartOk
offset = start_offset
client_properties, delta = deframe_table(buf, offset)
offset += delta
@@ -810,8 +757,7 @@ class ConnectionStartOk(AMQPMethodPayload):
offset += 1
locale = buf[offset:offset + s_len]
offset += s_len
- return ConnectionStartOk(client_properties, mechanism, response,
- locale)
+ return cls(client_properties, mechanism, response, locale)
class ConnectionSecureOk(AMQPMethodPayload):
@@ -821,6 +767,11 @@ class ConnectionSecureOk(AMQPMethodPayload):
This method attempts to authenticate, passing a block of SASL
data for the security
mechanism at the server side.
+ :param response: Security response data
+ A block of opaque data passed to the security mechanism. The
+ contents of this
+ data are defined by the SASL security mechanism.
+ :type response: binary type (longstr in AMQP)
"""
__slots__ = (u'response', )
@@ -835,27 +786,21 @@ class ConnectionSecureOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'response', u'longstr', u'longstr', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionSecureOk(%s)' % (', '.join(map(
- repr, [self.response])))
+ return 'ConnectionSecureOk(%s)' % (', '.join(map(repr, [self.response])))
def __init__(self, response):
"""
Create frame connection.secure-ok
-
- :param response: Security response data
- A block of opaque data passed to the security mechanism. The
- contents of this
- data are defined by the SASL security mechanism.
- :type response: binary type (longstr in AMQP)
"""
self.response = response
@@ -866,15 +811,14 @@ class ConnectionSecureOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 4 + len(self.response)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionSecureOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionSecureOk
offset = start_offset
s_len, = struct.unpack_from('!L', buf, offset)
offset += 4
response = buf[offset:offset + s_len]
offset += s_len
- return ConnectionSecureOk(response)
+ return cls(response)
class ConnectionTune(AMQPMethodPayload):
@@ -884,12 +828,28 @@ class ConnectionTune(AMQPMethodPayload):
This method proposes a set of connection configuration values to
the client. The
client can accept and/or adjust these.
+ :param channel_max: Proposed maximum channels
+ Specifies highest channel number that the server permits.
+ Usable channel numbers
+ are in the range 1..channel-max. Zero indicates no specified
+ limit.
+ :type channel_max: int, 16 bit unsigned (short in AMQP)
+ :param frame_max: Proposed maximum frame size
+ The largest frame size that the server proposes for the
+ connection, including
+ frame header and end-byte. The client can negotiate a lower
+ value. Zero means
+ that the server does not impose any specific limit but may
+ reject very large
+ frames if it cannot allocate resources for them.
+ :type frame_max: int, 32 bit unsigned (long in AMQP)
+ :param heartbeat: Desired heartbeat delay
+ The delay, in seconds, of the connection heartbeat that the
+ server wants.
+ Zero means the server does not want a heartbeat.
+ :type heartbeat: int, 16 bit unsigned (short in AMQP)
"""
- __slots__ = (
- u'channel_max',
- u'frame_max',
- u'heartbeat',
- )
+ __slots__ = (u'channel_max', u'frame_max', u'heartbeat',)
NAME = u'connection.tune'
@@ -911,56 +871,32 @@ class ConnectionTune(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionTune(%s)' % (', '.join(
- map(repr, [self.channel_max, self.frame_max, self.heartbeat])))
+ return 'ConnectionTune(%s)' % (
+ ', '.join(map(repr, [self.channel_max, self.frame_max, self.heartbeat])))
def __init__(self, channel_max, frame_max, heartbeat):
"""
Create frame connection.tune
-
- :param channel_max: Proposed maximum channels
- Specifies highest channel number that the server permits.
- Usable channel numbers
- are in the range 1..channel-max. Zero indicates no specified
- limit.
- :type channel_max: int, 16 bit unsigned (short in AMQP)
- :param frame_max: Proposed maximum frame size
- The largest frame size that the server proposes for the
- connection, including
- frame header and end-byte. The client can negotiate a lower
- value. Zero means
- that the server does not impose any specific limit but may
- reject very large
- frames if it cannot allocate resources for them.
- :type frame_max: int, 32 bit unsigned (long in AMQP)
- :param heartbeat: Desired heartbeat delay
- The delay, in seconds, of the connection heartbeat that the
- server wants.
- Zero means the server does not want a heartbeat.
- :type heartbeat: int, 16 bit unsigned (short in AMQP)
"""
self.channel_max = channel_max
self.frame_max = frame_max
self.heartbeat = heartbeat
def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
- buf.write(
- struct.pack('!HIH', self.channel_max, self.frame_max,
- self.heartbeat))
+ buf.write(struct.pack('!HIH', self.channel_max, self.frame_max, self.heartbeat))
def get_size(self): # type: () -> int
return 8
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionTune
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionTune
offset = start_offset
- channel_max, frame_max, heartbeat, = struct.unpack_from(
- '!HIH', buf, offset)
+ channel_max, frame_max, heartbeat, = struct.unpack_from('!HIH', buf, offset)
offset += 8
- return ConnectionTune(channel_max, frame_max, heartbeat)
+ return cls(channel_max, frame_max, heartbeat)
class ConnectionTuneOk(AMQPMethodPayload):
@@ -971,12 +907,28 @@ class ConnectionTuneOk(AMQPMethodPayload):
the server.
Certain fields are negotiated, others provide capability
information.
+ :param channel_max: Negotiated maximum channels
+ The maximum total number of channels that the client will
+ use per connection.
+ :type channel_max: int, 16 bit unsigned (short in AMQP)
+ :param frame_max: Negotiated maximum frame size
+ The largest frame size that the client and server will use
+ for the connection.
+ Zero means that the client does not impose any specific
+ limit but may reject
+ very large frames if it cannot allocate resources for them.
+ Note that the
+ frame-max limit applies principally to content frames, where
+ large contents can
+ be broken into frames of arbitrary size.
+ :type frame_max: int, 32 bit unsigned (long in AMQP)
+ :param heartbeat: Desired heartbeat delay
+ The delay, in seconds, of the connection heartbeat that the
+ client wants. Zero
+ means the client does not want a heartbeat.
+ :type heartbeat: int, 16 bit unsigned (short in AMQP)
"""
- __slots__ = (
- u'channel_max',
- u'frame_max',
- u'heartbeat',
- )
+ __slots__ = (u'channel_max', u'frame_max', u'heartbeat',)
NAME = u'connection.tune-ok'
@@ -998,56 +950,32 @@ class ConnectionTuneOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ConnectionTuneOk(%s)' % (', '.join(
- map(repr, [self.channel_max, self.frame_max, self.heartbeat])))
+ return 'ConnectionTuneOk(%s)' % (
+ ', '.join(map(repr, [self.channel_max, self.frame_max, self.heartbeat])))
def __init__(self, channel_max, frame_max, heartbeat):
"""
Create frame connection.tune-ok
-
- :param channel_max: Negotiated maximum channels
- The maximum total number of channels that the client will
- use per connection.
- :type channel_max: int, 16 bit unsigned (short in AMQP)
- :param frame_max: Negotiated maximum frame size
- The largest frame size that the client and server will use
- for the connection.
- Zero means that the client does not impose any specific
- limit but may reject
- very large frames if it cannot allocate resources for them.
- Note that the
- frame-max limit applies principally to content frames, where
- large contents can
- be broken into frames of arbitrary size.
- :type frame_max: int, 32 bit unsigned (long in AMQP)
- :param heartbeat: Desired heartbeat delay
- The delay, in seconds, of the connection heartbeat that the
- client wants. Zero
- means the client does not want a heartbeat.
- :type heartbeat: int, 16 bit unsigned (short in AMQP)
"""
self.channel_max = channel_max
self.frame_max = frame_max
self.heartbeat = heartbeat
def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
- buf.write(
- struct.pack('!HIH', self.channel_max, self.frame_max,
- self.heartbeat))
+ buf.write(struct.pack('!HIH', self.channel_max, self.frame_max, self.heartbeat))
def get_size(self): # type: () -> int
return 8
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConnectionTuneOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionTuneOk
offset = start_offset
- channel_max, frame_max, heartbeat, = struct.unpack_from(
- '!HIH', buf, offset)
+ channel_max, frame_max, heartbeat, = struct.unpack_from('!HIH', buf, offset)
offset += 8
- return ConnectionTuneOk(channel_max, frame_max, heartbeat)
+ return cls(channel_max, frame_max, heartbeat)
class ConnectionUnblocked(AMQPMethodPayload):
@@ -1072,20 +1000,15 @@ class ConnectionUnblocked(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConnectionUnblocked(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame connection.unblocked
- """
-
- @staticmethod
- def from_buffer(
- buf, start_offset): # type: (buffer, int) -> ConnectionUnblocked
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConnectionUnblocked
offset = start_offset
- return ConnectionUnblocked()
+ return cls()
class Channel(AMQPClass):
@@ -1111,13 +1034,19 @@ class ChannelClose(AMQPMethodPayload):
the sender provides
the class and method id of the method which caused the
exception.
+ :type reply_code: int, 16 bit unsigned (reply-code in AMQP)
+ :type reply_text: binary type (max length 255) (reply-text in AMQP)
+ :param class_id: Failing method class
+ When the close is provoked by a method exception, this is
+ the class of the
+ method.
+ :type class_id: int, 16 bit unsigned (class-id in AMQP)
+ :param method_id: Failing method id
+ When the close is provoked by a method exception, this is
+ the ID of the method.
+ :type method_id: int, 16 bit unsigned (method-id in AMQP)
"""
- __slots__ = (
- u'reply_code',
- u'reply_text',
- u'class_id',
- u'method_id',
- )
+ __slots__ = (u'reply_code', u'reply_text', u'class_id', u'method_id',)
NAME = u'channel.close'
@@ -1130,7 +1059,7 @@ class ChannelClose(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reply-code', u'reply-code', u'short', reserved=False),
Field(u'reply-text', u'reply-text', u'shortstr', reserved=False),
Field(u'class-id', u'class-id', u'short', reserved=False),
@@ -1140,28 +1069,15 @@ class ChannelClose(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ChannelClose(%s)' % (', '.join(
- map(repr, [
- self.reply_code, self.reply_text, self.class_id, self.method_id
- ])))
+ return 'ChannelClose(%s)' % (
+ ', '.join(map(repr, [self.reply_code, self.reply_text, self.class_id, self.method_id])))
def __init__(self, reply_code, reply_text, class_id, method_id):
"""
Create frame channel.close
-
- :type reply_code: int, 16 bit unsigned (reply-code in AMQP)
- :type reply_text: binary type (max length 255) (reply-text in AMQP)
- :param class_id: Failing method class
- When the close is provoked by a method exception, this is
- the class of the
- method.
- :type class_id: int, 16 bit unsigned (class-id in AMQP)
- :param method_id: Failing method id
- When the close is provoked by a method exception, this is
- the ID of the method.
- :type method_id: int, 16 bit unsigned (method-id in AMQP)
"""
self.reply_code = reply_code
self.reply_text = reply_text
@@ -1176,8 +1092,8 @@ class ChannelClose(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 7 + len(self.reply_text)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ChannelClose
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ChannelClose
offset = start_offset
reply_code, s_len, = struct.unpack_from('!HB', buf, offset)
offset += 3
@@ -1185,7 +1101,7 @@ class ChannelClose(AMQPMethodPayload):
offset += s_len
class_id, method_id, = struct.unpack_from('!HH', buf, offset)
offset += 4
- return ChannelClose(reply_code, reply_text, class_id, method_id)
+ return cls(reply_code, reply_text, class_id, method_id)
class ChannelCloseOk(AMQPMethodPayload):
@@ -1212,20 +1128,15 @@ class ChannelCloseOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ChannelCloseOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame channel.close-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ChannelCloseOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ChannelCloseOk
offset = start_offset
- return ChannelCloseOk()
+ return cls()
class ChannelFlow(AMQPMethodPayload):
@@ -1241,6 +1152,11 @@ class ChannelFlow(AMQPMethodPayload):
it can process. Note that this method is not intended for window
control. It does
not affect contents returned by Basic.Get-Ok methods.
+ :param active: Start/stop content frames
+ If 1, the peer starts sending content frames. If 0, the peer
+ stops sending
+ content frames.
+ :type active: bool (bit in AMQP)
"""
__slots__ = (u'active', )
@@ -1255,13 +1171,14 @@ class ChannelFlow(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'active', u'bit', u'bit', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ChannelFlow(%s)' % (', '.join(map(repr, [self.active])))
@@ -1269,12 +1186,6 @@ class ChannelFlow(AMQPMethodPayload):
def __init__(self, active):
"""
Create frame channel.flow
-
- :param active: Start/stop content frames
- If 1, the peer starts sending content frames. If 0, the peer
- stops sending
- content frames.
- :type active: bool (bit in AMQP)
"""
self.active = active
@@ -1284,14 +1195,14 @@ class ChannelFlow(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ChannelFlow
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ChannelFlow
offset = start_offset
_bit, = struct.unpack_from('!B', buf, offset)
offset += 0
active = bool(_bit >> 0)
offset += 1
- return ChannelFlow(active)
+ return cls(active)
class ChannelFlowOk(AMQPMethodPayload):
@@ -1300,6 +1211,12 @@ class ChannelFlowOk(AMQPMethodPayload):
Confirms to the peer that a flow command was received and
processed.
+ :param active: Current flow setting
+ Confirms the setting of the processed flow method: 1 means
+ the peer will start
+ sending or continue to send content frames; 0 means it will
+ not.
+ :type active: bool (bit in AMQP)
"""
__slots__ = (u'active', )
@@ -1314,13 +1231,14 @@ class ChannelFlowOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'active', u'bit', u'bit', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ChannelFlowOk(%s)' % (', '.join(map(repr, [self.active])))
@@ -1328,13 +1246,6 @@ class ChannelFlowOk(AMQPMethodPayload):
def __init__(self, active):
"""
Create frame channel.flow-ok
-
- :param active: Current flow setting
- Confirms the setting of the processed flow method: 1 means
- the peer will start
- sending or continue to send content frames; 0 means it will
- not.
- :type active: bool (bit in AMQP)
"""
self.active = active
@@ -1344,14 +1255,14 @@ class ChannelFlowOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ChannelFlowOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ChannelFlowOk
offset = start_offset
_bit, = struct.unpack_from('!B', buf, offset)
offset += 0
active = bool(_bit >> 0)
offset += 1
- return ChannelFlowOk(active)
+ return cls(active)
class ChannelOpen(AMQPMethodPayload):
@@ -1374,29 +1285,25 @@ class ChannelOpen(AMQPMethodPayload):
STATIC_CONTENT = b'\x00\x00\x00\x05\x00\x14\x00\x0A\x00\xCE' # spans LENGTH, CLASS ID, METHOD ID, ....., FRAME_END
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'shortstr', u'shortstr', reserved=True),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ChannelOpen(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame channel.open
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ChannelOpen
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ChannelOpen
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
offset += s_len # reserved field!
- return ChannelOpen()
+ return cls()
class ChannelOpenOk(AMQPMethodPayload):
@@ -1420,29 +1327,25 @@ class ChannelOpenOk(AMQPMethodPayload):
STATIC_CONTENT = b'\x00\x00\x00\x05\x00\x14\x00\x0B\x00\x00\x00\x00\xCE' # spans LENGTH, CLASS ID, METHOD ID, ....., FRAME_END
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'longstr', u'longstr', reserved=True),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ChannelOpenOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame channel.open-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ChannelOpenOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ChannelOpenOk
offset = start_offset
s_len, = struct.unpack_from('!L', buf, offset)
offset += 4
offset += s_len # reserved field!
- return ChannelOpenOk()
+ return cls()
class Exchange(AMQPClass):
@@ -1461,14 +1364,25 @@ class ExchangeBind(AMQPMethodPayload):
Bind exchange to an exchange
This method binds an exchange to an exchange.
+ :param destination: Name of the destination exchange to bind to
+ Specifies the name of the destination exchange to bind.
+ :type destination: binary type (max length 255) (exchange-name in AMQP)
+ :param source: Name of the source exchange to bind to
+ Specifies the name of the source exchange to bind.
+ :type source: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Message routing key
+ Specifies the routing key for the binding. The routing key
+ is used for routing messages depending on the exchange
+ configuration. Not all exchanges use a routing key - refer
+ to the specific exchange documentation.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
+ :param arguments: Arguments for binding
+ A set of arguments for the binding. The syntax and semantics
+ of these arguments depends on the exchange class.
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
- __slots__ = (
- u'destination',
- u'source',
- u'routing_key',
- u'no_wait',
- u'arguments',
- )
+ __slots__ = (u'destination', u'source', u'routing_key', u'no_wait', u'arguments',)
NAME = u'exchange.bind'
@@ -1481,7 +1395,7 @@ class ExchangeBind(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'destination', u'exchange-name', u'shortstr', reserved=False),
Field(u'source', u'exchange-name', u'shortstr', reserved=False),
@@ -1493,35 +1407,16 @@ class ExchangeBind(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ExchangeBind(%s)' % (', '.join(
- map(repr, [
- self.destination, self.source, self.routing_key, self.no_wait,
- self.arguments
- ])))
+ return 'ExchangeBind(%s)' % (', '.join(map(repr,
+ [self.destination, self.source, self.routing_key,
+ self.no_wait, self.arguments])))
def __init__(self, destination, source, routing_key, no_wait, arguments):
"""
Create frame exchange.bind
-
- :param destination: Name of the destination exchange to bind to
- Specifies the name of the destination exchange to bind.
- :type destination: binary type (max length 255) (exchange-name in AMQP)
- :param source: Name of the source exchange to bind to
- Specifies the name of the source exchange to bind.
- :type source: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Message routing key
- Specifies the routing key for the binding. The routing key
- is used for routing messages depending on the exchange
- configuration. Not all exchanges use a routing key - refer
- to the specific exchange documentation.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
- :type no_wait: bool (no-wait in AMQP)
- :param arguments: Arguments for binding
- A set of arguments for the binding. The syntax and semantics
- of these arguments depends on the exchange class.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
self.destination = destination
self.source = source
@@ -1544,8 +1439,8 @@ class ExchangeBind(AMQPMethodPayload):
return 6 + len(self.destination) + len(self.source) + len(
self.routing_key) + frame_table_size(self.arguments)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ExchangeBind
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeBind
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -1565,8 +1460,7 @@ class ExchangeBind(AMQPMethodPayload):
offset += 1
arguments, delta = deframe_table(buf, offset)
offset += delta
- return ExchangeBind(destination, source, routing_key, no_wait,
- arguments)
+ return cls(destination, source, routing_key, no_wait, arguments)
class ExchangeBindOk(AMQPMethodPayload):
@@ -1591,20 +1485,15 @@ class ExchangeBindOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ExchangeBindOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame exchange.bind-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeBindOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeBindOk
offset = start_offset
- return ExchangeBindOk()
+ return cls()
class ExchangeDeclare(AMQPMethodPayload):
@@ -1614,65 +1503,14 @@ class ExchangeDeclare(AMQPMethodPayload):
This method creates an exchange if it does not already exist,
and if the exchange
exists, verifies that it is of the correct and expected class.
- """
- __slots__ = (
- u'exchange',
- u'type_',
- u'passive',
- u'durable',
- u'auto_delete',
- u'internal',
- u'no_wait',
- u'arguments',
- )
-
- NAME = u'exchange.declare'
-
- INDEX = (40, 10) # (Class ID, Method ID)
- BINARY_HEADER = b'\x00\x28\x00\x0A' # CLASS ID + METHOD ID
-
- SENT_BY_CLIENT, SENT_BY_SERVER = False, True
-
- IS_SIZE_STATIC = False # this means that argument part has always the same length
- IS_CONTENT_STATIC = False # this means that argument part has always the same content
-
- # See constructor pydoc for details
- FIELDS = [
- Field(u'reserved-1', u'short', u'short', reserved=True),
- Field(u'exchange', u'exchange-name', u'shortstr', reserved=False),
- Field(u'type', u'shortstr', u'shortstr', reserved=False),
- Field(u'passive', u'bit', u'bit', reserved=False),
- Field(u'durable', u'bit', u'bit', reserved=False),
- Field(u'auto-delete', u'bit', u'bit', reserved=False),
- Field(u'internal', u'bit', u'bit', reserved=False),
- Field(u'no-wait', u'no-wait', u'bit', reserved=False),
- Field(u'arguments', u'table', u'table', reserved=False),
- ]
-
- def __repr__(self): # type: () -> str
- """
- Convert the frame to a Python-representable string
- :return: Python string representation
- """
- return 'ExchangeDeclare(%s)' % (', '.join(
- map(repr, [
- self.exchange, self.type_, self.passive, self.durable,
- self.auto_delete, self.internal, self.no_wait, self.arguments
- ])))
-
- def __init__(self, exchange, type_, passive, durable, auto_delete,
- internal, no_wait, arguments):
- """
- Create frame exchange.declare
-
- :param exchange: Exchange names starting with "amq." are reserved for
+ :param exchange: Exchange names starting with "amq." are reserved for
pre-declared and
standardised exchanges. The client MAY declare an
exchange starting with
"amq." if the passive option is set, or the exchange
already exists.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param type_: Exchange type
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param type_: Exchange type
Each exchange belongs to one of a set of exchange types
implemented by the
server. The exchange types define the functionality of the
@@ -1680,8 +1518,8 @@ class ExchangeDeclare(AMQPMethodPayload):
messages are routed through it. It is not valid or
meaningful to attempt to
change the type of an existing exchange.
- :type type_: binary type (max length 255) (shortstr in AMQP)
- :param passive: Do not create exchange
+ :type type_: binary type (max length 255) (shortstr in AMQP)
+ :param passive: Do not create exchange
If set, the server will reply with Declare-Ok if the
exchange already
exists with the same name, and raise an error if not. The
@@ -1693,30 +1531,74 @@ class ExchangeDeclare(AMQPMethodPayload):
are ignored. A declare with both passive and no-wait has no
effect.
Arguments are compared for semantic equivalence.
- :type passive: bool (bit in AMQP)
- :param durable: Request a durable exchange
+ :type passive: bool (bit in AMQP)
+ :param durable: Request a durable exchange
If set when creating a new exchange, the exchange will be
marked as durable.
Durable exchanges remain active when a server restarts.
Non-durable exchanges
(transient exchanges) are purged if/when a server restarts.
- :type durable: bool (bit in AMQP)
- :param auto_delete: Auto-delete when unused
+ :type durable: bool (bit in AMQP)
+ :param auto_delete: Auto-delete when unused
If set, the exchange is deleted when all queues have
finished using it.
- :type auto_delete: bool (bit in AMQP)
- :param internal: Create internal exchange
+ :type auto_delete: bool (bit in AMQP)
+ :param internal: Create internal exchange
If set, the exchange may not be used directly by publishers,
but only when bound to other exchanges. Internal exchanges
are used to construct wiring that is not visible to
applications.
- :type internal: bool (bit in AMQP)
- :type no_wait: bool (no-wait in AMQP)
- :param arguments: Arguments for declaration
+ :type internal: bool (bit in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
+ :param arguments: Arguments for declaration
A set of arguments for the declaration. The syntax and
semantics of these
arguments depends on the server implementation.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
+ """
+ __slots__ = (
+ u'exchange', u'type_', u'passive', u'durable', u'auto_delete', u'internal', u'no_wait',
+ u'arguments',)
+
+ NAME = u'exchange.declare'
+
+ INDEX = (40, 10) # (Class ID, Method ID)
+ BINARY_HEADER = b'\x00\x28\x00\x0A' # CLASS ID + METHOD ID
+
+ SENT_BY_CLIENT, SENT_BY_SERVER = False, True
+
+ IS_SIZE_STATIC = False # this means that argument part has always the same length
+ IS_CONTENT_STATIC = False # this means that argument part has always the same content
+
+ # See constructor pydoc for details
+ FIELDS = [
+ Field(u'reserved-1', u'short', u'short', reserved=True),
+ Field(u'exchange', u'exchange-name', u'shortstr', reserved=False),
+ Field(u'type', u'shortstr', u'shortstr', reserved=False),
+ Field(u'passive', u'bit', u'bit', reserved=False),
+ Field(u'durable', u'bit', u'bit', reserved=False),
+ Field(u'auto-delete', u'bit', u'bit', reserved=False),
+ Field(u'internal', u'bit', u'bit', reserved=False),
+ Field(u'no-wait', u'no-wait', u'bit', reserved=False),
+ Field(u'arguments', u'table', u'table', reserved=False),
+ ]
+
+ def __repr__(self): # type: () -> str
+ """
+ Convert the frame to a Python-representable string
+
+ :return: Python string representation
+ """
+ return 'ExchangeDeclare(%s)' % (', '.join(map(repr,
+ [self.exchange, self.type_, self.passive,
+ self.durable, self.auto_delete,
+ self.internal, self.no_wait,
+ self.arguments])))
+
+ def __init__(self, exchange, type_, passive, durable, auto_delete, internal, no_wait,
+ arguments):
+ """
+ Create frame exchange.declare
"""
self.exchange = exchange
self.type_ = type_
@@ -1733,19 +1615,15 @@ class ExchangeDeclare(AMQPMethodPayload):
buf.write(self.exchange)
buf.write(struct.pack('!B', len(self.type_)))
buf.write(self.type_)
- buf.write(
- struct.pack('!B', (self.passive << 0) | (self.durable << 1) |
- (self.auto_delete << 2) | (self.internal << 3) |
- (self.no_wait << 4)))
+ buf.write(struct.pack('!B', (self.passive << 0) | (self.durable << 1) | (
+ self.auto_delete << 2) | (self.internal << 3) | (self.no_wait << 4)))
enframe_table(buf, self.arguments)
def get_size(self): # type: () -> int
- return 5 + len(self.exchange) + len(self.type_) + frame_table_size(
- self.arguments)
+ return 5 + len(self.exchange) + len(self.type_) + frame_table_size(self.arguments)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeDeclare
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeDeclare
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -1765,8 +1643,7 @@ class ExchangeDeclare(AMQPMethodPayload):
offset += 1
arguments, delta = deframe_table(buf, offset)
offset += delta
- return ExchangeDeclare(exchange, type_, passive, durable, auto_delete,
- internal, no_wait, arguments)
+ return cls(exchange, type_, passive, durable, auto_delete, internal, no_wait, arguments)
class ExchangeDelete(AMQPMethodPayload):
@@ -1776,12 +1653,19 @@ class ExchangeDelete(AMQPMethodPayload):
This method deletes an exchange. When an exchange is deleted all
queue bindings on
the exchange are cancelled.
+ :param exchange: The client must not attempt to delete an exchange that
+ does not exist.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param if_unused: Delete only if unused
+ If set, the server will only delete the exchange if it has
+ no queue bindings. If
+ the exchange has queue bindings the server does not delete
+ it but raises a
+ channel exception instead.
+ :type if_unused: bool (bit in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
"""
- __slots__ = (
- u'exchange',
- u'if_unused',
- u'no_wait',
- )
+ __slots__ = (u'exchange', u'if_unused', u'no_wait',)
NAME = u'exchange.delete'
@@ -1794,7 +1678,7 @@ class ExchangeDelete(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'exchange', u'exchange-name', u'shortstr', reserved=False),
Field(u'if-unused', u'bit', u'bit', reserved=False),
@@ -1804,26 +1688,15 @@ class ExchangeDelete(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ExchangeDelete(%s)' % (', '.join(
- map(repr, [self.exchange, self.if_unused, self.no_wait])))
+ return 'ExchangeDelete(%s)' % (
+ ', '.join(map(repr, [self.exchange, self.if_unused, self.no_wait])))
def __init__(self, exchange, if_unused, no_wait):
"""
Create frame exchange.delete
-
- :param exchange: The client must not attempt to delete an exchange that
- does not exist.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param if_unused: Delete only if unused
- If set, the server will only delete the exchange if it has
- no queue bindings. If
- the exchange has queue bindings the server does not delete
- it but raises a
- channel exception instead.
- :type if_unused: bool (bit in AMQP)
- :type no_wait: bool (no-wait in AMQP)
"""
self.exchange = exchange
self.if_unused = if_unused
@@ -1833,15 +1706,13 @@ class ExchangeDelete(AMQPMethodPayload):
buf.write(b'\x00\x00')
buf.write(struct.pack('!B', len(self.exchange)))
buf.write(self.exchange)
- buf.write(
- struct.pack('!B', (self.if_unused << 0) | (self.no_wait << 1)))
+ buf.write(struct.pack('!B', (self.if_unused << 0) | (self.no_wait << 1)))
def get_size(self): # type: () -> int
return 4 + len(self.exchange)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeDelete
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeDelete
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -1852,7 +1723,7 @@ class ExchangeDelete(AMQPMethodPayload):
if_unused = bool(_bit >> 0)
no_wait = bool(_bit >> 1)
offset += 1
- return ExchangeDelete(exchange, if_unused, no_wait)
+ return cls(exchange, if_unused, no_wait)
class ExchangeDeclareOk(AMQPMethodPayload):
@@ -1879,20 +1750,15 @@ class ExchangeDeclareOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ExchangeDeclareOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame exchange.declare-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeDeclareOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeDeclareOk
offset = start_offset
- return ExchangeDeclareOk()
+ return cls()
class ExchangeDeleteOk(AMQPMethodPayload):
@@ -1917,20 +1783,15 @@ class ExchangeDeleteOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ExchangeDeleteOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame exchange.delete-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeDeleteOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeDeleteOk
offset = start_offset
- return ExchangeDeleteOk()
+ return cls()
class ExchangeUnbind(AMQPMethodPayload):
@@ -1938,14 +1799,19 @@ class ExchangeUnbind(AMQPMethodPayload):
Unbind an exchange from an exchange
This method unbinds an exchange from an exchange.
+ :param destination: Specifies the name of the destination exchange to unbind.
+ :type destination: binary type (max length 255) (exchange-name in AMQP)
+ :param source: Specifies the name of the source exchange to unbind.
+ :type source: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Routing key of binding
+ Specifies the routing key of the binding to unbind.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
+ :param arguments: Arguments of binding
+ Specifies the arguments of the binding to unbind.
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
- __slots__ = (
- u'destination',
- u'source',
- u'routing_key',
- u'no_wait',
- u'arguments',
- )
+ __slots__ = (u'destination', u'source', u'routing_key', u'no_wait', u'arguments',)
NAME = u'exchange.unbind'
@@ -1958,7 +1824,7 @@ class ExchangeUnbind(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'destination', u'exchange-name', u'shortstr', reserved=False),
Field(u'source', u'exchange-name', u'shortstr', reserved=False),
@@ -1970,29 +1836,16 @@ class ExchangeUnbind(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'ExchangeUnbind(%s)' % (', '.join(
- map(repr, [
- self.destination, self.source, self.routing_key, self.no_wait,
- self.arguments
- ])))
+ return 'ExchangeUnbind(%s)' % (', '.join(map(repr, [self.destination, self.source,
+ self.routing_key, self.no_wait,
+ self.arguments])))
def __init__(self, destination, source, routing_key, no_wait, arguments):
"""
Create frame exchange.unbind
-
- :param destination: Specifies the name of the destination exchange to unbind.
- :type destination: binary type (max length 255) (exchange-name in AMQP)
- :param source: Specifies the name of the source exchange to unbind.
- :type source: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Routing key of binding
- Specifies the routing key of the binding to unbind.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
- :type no_wait: bool (no-wait in AMQP)
- :param arguments: Arguments of binding
- Specifies the arguments of the binding to unbind.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
self.destination = destination
self.source = source
@@ -2015,9 +1868,8 @@ class ExchangeUnbind(AMQPMethodPayload):
return 6 + len(self.destination) + len(self.source) + len(
self.routing_key) + frame_table_size(self.arguments)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeUnbind
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeUnbind
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -2037,8 +1889,7 @@ class ExchangeUnbind(AMQPMethodPayload):
offset += 1
arguments, delta = deframe_table(buf, offset)
offset += delta
- return ExchangeUnbind(destination, source, routing_key, no_wait,
- arguments)
+ return cls(destination, source, routing_key, no_wait, arguments)
class ExchangeUnbindOk(AMQPMethodPayload):
@@ -2063,20 +1914,15 @@ class ExchangeUnbindOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ExchangeUnbindOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame exchange.unbind-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ExchangeUnbindOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ExchangeUnbindOk
offset = start_offset
- return ExchangeUnbindOk()
+ return cls()
class Queue(AMQPClass):
@@ -2103,14 +1949,37 @@ class QueueBind(AMQPMethodPayload):
are bound to a direct exchange and subscription queues are bound
to a topic
exchange.
+ :param queue: Specifies the name of the queue to bind.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :param exchange: Name of the exchange to bind to
+ A client MUST NOT be allowed to bind a queue to a
+ non-existent exchange.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Message routing key
+ Specifies the routing key for the binding. The routing key
+ is used for routing
+ messages depending on the exchange configuration. Not all
+ exchanges use a
+ routing key - refer to the specific exchange documentation.
+ If the queue name
+ is empty, the server uses the last queue declared on the
+ channel. If the
+ routing key is also empty, the server uses this queue name
+ for the routing
+ key as well. If the queue name is provided but the routing
+ key is empty, the
+ server does the binding with that empty routing key. The
+ meaning of empty
+ routing keys depends on the exchange implementation.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
+ :param arguments: Arguments for binding
+ A set of arguments for the binding. The syntax and semantics
+ of these arguments
+ depends on the exchange class.
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
- __slots__ = (
- u'queue',
- u'exchange',
- u'routing_key',
- u'no_wait',
- u'arguments',
- )
+ __slots__ = (u'queue', u'exchange', u'routing_key', u'no_wait', u'arguments',)
NAME = u'queue.bind'
@@ -2135,47 +2004,15 @@ class QueueBind(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'QueueBind(%s)' % (', '.join(
- map(repr, [
- self.queue, self.exchange, self.routing_key, self.no_wait,
- self.arguments
- ])))
+ map(repr, [self.queue, self.exchange, self.routing_key, self.no_wait, self.arguments])))
def __init__(self, queue, exchange, routing_key, no_wait, arguments):
"""
Create frame queue.bind
-
- :param queue: Specifies the name of the queue to bind.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :param exchange: Name of the exchange to bind to
- A client MUST NOT be allowed to bind a queue to a
- non-existent exchange.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Message routing key
- Specifies the routing key for the binding. The routing key
- is used for routing
- messages depending on the exchange configuration. Not all
- exchanges use a
- routing key - refer to the specific exchange documentation.
- If the queue name
- is empty, the server uses the last queue declared on the
- channel. If the
- routing key is also empty, the server uses this queue name
- for the routing
- key as well. If the queue name is provided but the routing
- key is empty, the
- server does the binding with that empty routing key. The
- meaning of empty
- routing keys depends on the exchange implementation.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
- :type no_wait: bool (no-wait in AMQP)
- :param arguments: Arguments for binding
- A set of arguments for the binding. The syntax and semantics
- of these arguments
- depends on the exchange class.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
self.queue = queue
self.exchange = exchange
@@ -2195,11 +2032,11 @@ class QueueBind(AMQPMethodPayload):
enframe_table(buf, self.arguments)
def get_size(self): # type: () -> int
- return 6 + len(self.queue) + len(self.exchange) + len(
- self.routing_key) + frame_table_size(self.arguments)
+ return 6 + len(self.queue) + len(self.exchange) + len(self.routing_key) + frame_table_size(
+ self.arguments)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueBind
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueBind
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -2219,7 +2056,7 @@ class QueueBind(AMQPMethodPayload):
offset += 1
arguments, delta = deframe_table(buf, offset)
offset += delta
- return QueueBind(queue, exchange, routing_key, no_wait, arguments)
+ return cls(queue, exchange, routing_key, no_wait, arguments)
class QueueBindOk(AMQPMethodPayload):
@@ -2244,19 +2081,15 @@ class QueueBindOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'QueueBindOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame queue.bind-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueBindOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueBindOk
offset = start_offset
- return QueueBindOk()
+ return cls()
class QueueDeclare(AMQPMethodPayload):
@@ -2268,62 +2101,13 @@ class QueueDeclare(AMQPMethodPayload):
specify various properties that control the durability of the
queue and its
contents, and the level of sharing for the queue.
- """
- __slots__ = (
- u'queue',
- u'passive',
- u'durable',
- u'exclusive',
- u'auto_delete',
- u'no_wait',
- u'arguments',
- )
-
- NAME = u'queue.declare'
-
- INDEX = (50, 10) # (Class ID, Method ID)
- BINARY_HEADER = b'\x00\x32\x00\x0A' # CLASS ID + METHOD ID
-
- SENT_BY_CLIENT, SENT_BY_SERVER = False, True
-
- IS_SIZE_STATIC = False # this means that argument part has always the same length
- IS_CONTENT_STATIC = False # this means that argument part has always the same content
-
- # See constructor pydoc for details
- FIELDS = [
- Field(u'reserved-1', u'short', u'short', reserved=True),
- Field(u'queue', u'queue-name', u'shortstr', reserved=False),
- Field(u'passive', u'bit', u'bit', reserved=False),
- Field(u'durable', u'bit', u'bit', reserved=False),
- Field(u'exclusive', u'bit', u'bit', reserved=False),
- Field(u'auto-delete', u'bit', u'bit', reserved=False),
- Field(u'no-wait', u'no-wait', u'bit', reserved=False),
- Field(u'arguments', u'table', u'table', reserved=False),
- ]
-
- def __repr__(self): # type: () -> str
- """
- Convert the frame to a Python-representable string
- :return: Python string representation
- """
- return 'QueueDeclare(%s)' % (', '.join(
- map(repr, [
- self.queue, self.passive, self.durable, self.exclusive,
- self.auto_delete, self.no_wait, self.arguments
- ])))
-
- def __init__(self, queue, passive, durable, exclusive, auto_delete,
- no_wait, arguments):
- """
- Create frame queue.declare
-
- :param queue: The queue name may be empty, in which case the server
+ :param queue: The queue name may be empty, in which case the server
MUST create a new
queue with a unique generated name and return this to
the client in the
Declare-Ok method.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :param passive: Do not create queue
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :param passive: Do not create queue
If set, the server will reply with Declare-Ok if the queue
already
exists with the same name, and raise an error if not. The
@@ -2335,8 +2119,8 @@ class QueueDeclare(AMQPMethodPayload):
are ignored. A declare with both passive and no-wait has no
effect.
Arguments are compared for semantic equivalence.
- :type passive: bool (bit in AMQP)
- :param durable: Request a durable queue
+ :type passive: bool (bit in AMQP)
+ :param durable: Request a durable queue
If set when creating a new queue, the queue will be marked
as durable. Durable
queues remain active when a server restarts. Non-durable
@@ -2346,15 +2130,15 @@ class QueueDeclare(AMQPMethodPayload):
necessarily hold persistent messages, although it does not
make sense to send
persistent messages to a transient queue.
- :type durable: bool (bit in AMQP)
- :param exclusive: Request an exclusive queue
+ :type durable: bool (bit in AMQP)
+ :param exclusive: Request an exclusive queue
Exclusive queues may only be accessed by the current
connection, and are
deleted when that connection closes. Passive declaration of
an exclusive
queue by other connections are not allowed.
- :type exclusive: bool (bit in AMQP)
- :param auto_delete: Auto-delete queue when unused
+ :type exclusive: bool (bit in AMQP)
+ :param auto_delete: Auto-delete queue when unused
If set, the queue is deleted when all consumers have
finished using it. The last
consumer can be cancelled either explicitly or because its
@@ -2363,37 +2147,75 @@ class QueueDeclare(AMQPMethodPayload):
deleted. Applications can
explicitly delete auto-delete queues using the Delete method
as normal.
- :type auto_delete: bool (bit in AMQP)
- :type no_wait: bool (no-wait in AMQP)
- :param arguments: Arguments for declaration
+ :type auto_delete: bool (bit in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
+ :param arguments: Arguments for declaration
A set of arguments for the declaration. The syntax and
semantics of these
arguments depends on the server implementation.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
- """
- self.queue = queue
- self.passive = passive
- self.durable = durable
- self.exclusive = exclusive
- self.auto_delete = auto_delete
- self.no_wait = no_wait
- self.arguments = arguments
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
+ """
+ __slots__ = (
+ u'queue', u'passive', u'durable', u'exclusive', u'auto_delete', u'no_wait', u'arguments',)
- def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
- buf.write(b'\x00\x00')
- buf.write(struct.pack('!B', len(self.queue)))
- buf.write(self.queue)
- buf.write(
- struct.pack('!B', (self.passive << 0) | (self.durable << 1) |
- (self.exclusive << 2) | (self.auto_delete << 3) |
- (self.no_wait << 4)))
- enframe_table(buf, self.arguments)
+ NAME = u'queue.declare'
- def get_size(self): # type: () -> int
- return 4 + len(self.queue) + frame_table_size(self.arguments)
+ INDEX = (50, 10) # (Class ID, Method ID)
+ BINARY_HEADER = b'\x00\x32\x00\x0A' # CLASS ID + METHOD ID
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueDeclare
+ SENT_BY_CLIENT, SENT_BY_SERVER = False, True
+
+ IS_SIZE_STATIC = False # this means that argument part has always the same length
+ IS_CONTENT_STATIC = False # this means that argument part has always the same content
+
+ # See constructor pydoc for details
+ FIELDS = [
+ Field(u'reserved-1', u'short', u'short', reserved=True),
+ Field(u'queue', u'queue-name', u'shortstr', reserved=False),
+ Field(u'passive', u'bit', u'bit', reserved=False),
+ Field(u'durable', u'bit', u'bit', reserved=False),
+ Field(u'exclusive', u'bit', u'bit', reserved=False),
+ Field(u'auto-delete', u'bit', u'bit', reserved=False),
+ Field(u'no-wait', u'no-wait', u'bit', reserved=False),
+ Field(u'arguments', u'table', u'table', reserved=False),
+ ]
+
+ def __repr__(self): # type: () -> str
+ """
+ Convert the frame to a Python-representable string
+
+ :return: Python string representation
+ """
+ return 'QueueDeclare(%s)' % (', '.join(map(repr, [self.queue, self.passive, self.durable,
+ self.exclusive, self.auto_delete,
+ self.no_wait, self.arguments])))
+
+ def __init__(self, queue, passive, durable, exclusive, auto_delete, no_wait, arguments):
+ """
+ Create frame queue.declare
+ """
+ self.queue = queue
+ self.passive = passive
+ self.durable = durable
+ self.exclusive = exclusive
+ self.auto_delete = auto_delete
+ self.no_wait = no_wait
+ self.arguments = arguments
+
+ def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
+ buf.write(b'\x00\x00')
+ buf.write(struct.pack('!B', len(self.queue)))
+ buf.write(self.queue)
+ buf.write(struct.pack('!B',
+ (self.passive << 0) | (self.durable << 1) | (self.exclusive << 2) | (
+ self.auto_delete << 3) | (self.no_wait << 4)))
+ enframe_table(buf, self.arguments)
+
+ def get_size(self): # type: () -> int
+ return 4 + len(self.queue) + frame_table_size(self.arguments)
+
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueDeclare
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -2409,8 +2231,7 @@ class QueueDeclare(AMQPMethodPayload):
offset += 1
arguments, delta = deframe_table(buf, offset)
offset += delta
- return QueueDeclare(queue, passive, durable, exclusive, auto_delete,
- no_wait, arguments)
+ return cls(queue, passive, durable, exclusive, auto_delete, no_wait, arguments)
class QueueDelete(AMQPMethodPayload):
@@ -2422,13 +2243,22 @@ class QueueDelete(AMQPMethodPayload):
to a dead-letter queue if this is defined in the server
configuration, and all
consumers on the queue are cancelled.
+ :param queue: Specifies the name of the queue to delete.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :param if_unused: Delete only if unused
+ If set, the server will only delete the queue if it has no
+ consumers. If the
+ queue has consumers the server does does not delete it but
+ raises a channel
+ exception instead.
+ :type if_unused: bool (bit in AMQP)
+ :param if_empty: Delete only if empty
+ If set, the server will only delete the queue if it has no
+ messages.
+ :type if_empty: bool (bit in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
"""
- __slots__ = (
- u'queue',
- u'if_unused',
- u'if_empty',
- u'no_wait',
- )
+ __slots__ = (u'queue', u'if_unused', u'if_empty', u'no_wait',)
NAME = u'queue.delete'
@@ -2441,7 +2271,7 @@ class QueueDelete(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'queue', u'queue-name', u'shortstr', reserved=False),
Field(u'if-unused', u'bit', u'bit', reserved=False),
@@ -2452,30 +2282,15 @@ class QueueDelete(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'QueueDelete(%s)' % (', '.join(
- map(repr,
- [self.queue, self.if_unused, self.if_empty, self.no_wait])))
+ return 'QueueDelete(%s)' % (
+ ', '.join(map(repr, [self.queue, self.if_unused, self.if_empty, self.no_wait])))
def __init__(self, queue, if_unused, if_empty, no_wait):
"""
Create frame queue.delete
-
- :param queue: Specifies the name of the queue to delete.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :param if_unused: Delete only if unused
- If set, the server will only delete the queue if it has no
- consumers. If the
- queue has consumers the server does does not delete it but
- raises a channel
- exception instead.
- :type if_unused: bool (bit in AMQP)
- :param if_empty: Delete only if empty
- If set, the server will only delete the queue if it has no
- messages.
- :type if_empty: bool (bit in AMQP)
- :type no_wait: bool (no-wait in AMQP)
"""
self.queue = queue
self.if_unused = if_unused
@@ -2487,14 +2302,13 @@ class QueueDelete(AMQPMethodPayload):
buf.write(struct.pack('!B', len(self.queue)))
buf.write(self.queue)
buf.write(
- struct.pack('!B', (self.if_unused << 0) | (self.if_empty << 1) |
- (self.no_wait << 2)))
+ struct.pack('!B', (self.if_unused << 0) | (self.if_empty << 1) | (self.no_wait << 2)))
def get_size(self): # type: () -> int
return 4 + len(self.queue)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueDelete
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueDelete
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -2506,7 +2320,7 @@ class QueueDelete(AMQPMethodPayload):
if_empty = bool(_bit >> 1)
no_wait = bool(_bit >> 2)
offset += 1
- return QueueDelete(queue, if_unused, if_empty, no_wait)
+ return cls(queue, if_unused, if_empty, no_wait)
class QueueDeclareOk(AMQPMethodPayload):
@@ -2516,12 +2330,19 @@ class QueueDeclareOk(AMQPMethodPayload):
This method confirms a Declare method and confirms the name of
the queue, essential
for automatically-named queues.
+ :param queue: Reports the name of the queue. if the server generated a
+ queue name, this field
+ contains that name.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :type message_count: int, 32 bit unsigned (message-count in AMQP)
+ :param consumer_count: Number of consumers
+ Reports the number of active consumers for the queue. Note
+ that consumers can
+ suspend activity (Channel.Flow) in which case they do not
+ appear in this count.
+ :type consumer_count: int, 32 bit unsigned (long in AMQP)
"""
- __slots__ = (
- u'queue',
- u'message_count',
- u'consumer_count',
- )
+ __slots__ = (u'queue', u'message_count', u'consumer_count',)
NAME = u'queue.declare-ok'
@@ -2534,7 +2355,7 @@ class QueueDeclareOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'queue', u'queue-name', u'shortstr', reserved=False),
Field(u'message-count', u'message-count', u'long', reserved=False),
Field(u'consumer-count', u'long', u'long', reserved=False),
@@ -2543,26 +2364,15 @@ class QueueDeclareOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'QueueDeclareOk(%s)' % (', '.join(
- map(repr, [self.queue, self.message_count, self.consumer_count])))
+ return 'QueueDeclareOk(%s)' % (
+ ', '.join(map(repr, [self.queue, self.message_count, self.consumer_count])))
def __init__(self, queue, message_count, consumer_count):
"""
Create frame queue.declare-ok
-
- :param queue: Reports the name of the queue. if the server generated a
- queue name, this field
- contains that name.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :type message_count: int, 32 bit unsigned (message-count in AMQP)
- :param consumer_count: Number of consumers
- Reports the number of active consumers for the queue. Note
- that consumers can
- suspend activity (Channel.Flow) in which case they do not
- appear in this count.
- :type consumer_count: int, 32 bit unsigned (long in AMQP)
"""
self.queue = queue
self.message_count = message_count
@@ -2576,9 +2386,8 @@ class QueueDeclareOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 9 + len(self.queue)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> QueueDeclareOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueDeclareOk
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
@@ -2586,7 +2395,7 @@ class QueueDeclareOk(AMQPMethodPayload):
offset += s_len
message_count, consumer_count, = struct.unpack_from('!II', buf, offset)
offset += 8
- return QueueDeclareOk(queue, message_count, consumer_count)
+ return cls(queue, message_count, consumer_count)
class QueueDeleteOk(AMQPMethodPayload):
@@ -2594,6 +2403,8 @@ class QueueDeleteOk(AMQPMethodPayload):
Confirm deletion of a queue
This method confirms the deletion of a queue.
+ :param message_count: Reports the number of messages deleted.
+ :type message_count: int, 32 bit unsigned (message-count in AMQP)
"""
__slots__ = (u'message_count', )
@@ -2608,24 +2419,21 @@ class QueueDeleteOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'message-count', u'message-count', u'long', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'QueueDeleteOk(%s)' % (', '.join(map(repr,
- [self.message_count])))
+ return 'QueueDeleteOk(%s)' % (', '.join(map(repr, [self.message_count])))
def __init__(self, message_count):
"""
Create frame queue.delete-ok
-
- :param message_count: Reports the number of messages deleted.
- :type message_count: int, 32 bit unsigned (message-count in AMQP)
"""
self.message_count = message_count
@@ -2635,12 +2443,12 @@ class QueueDeleteOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 4
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueDeleteOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueDeleteOk
offset = start_offset
message_count, = struct.unpack_from('!I', buf, offset)
offset += 4
- return QueueDeleteOk(message_count)
+ return cls(message_count)
class QueuePurge(AMQPMethodPayload):
@@ -2650,11 +2458,11 @@ class QueuePurge(AMQPMethodPayload):
This method removes all messages from a queue which are not
awaiting
acknowledgment.
+ :param queue: Specifies the name of the queue to purge.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
"""
- __slots__ = (
- u'queue',
- u'no_wait',
- )
+ __slots__ = (u'queue', u'no_wait',)
NAME = u'queue.purge'
@@ -2667,7 +2475,7 @@ class QueuePurge(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'queue', u'queue-name', u'shortstr', reserved=False),
Field(u'no-wait', u'no-wait', u'bit', reserved=False),
@@ -2676,18 +2484,14 @@ class QueuePurge(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'QueuePurge(%s)' % (', '.join(
- map(repr, [self.queue, self.no_wait])))
+ return 'QueuePurge(%s)' % (', '.join(map(repr, [self.queue, self.no_wait])))
def __init__(self, queue, no_wait):
"""
Create frame queue.purge
-
- :param queue: Specifies the name of the queue to purge.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :type no_wait: bool (no-wait in AMQP)
"""
self.queue = queue
self.no_wait = no_wait
@@ -2701,8 +2505,8 @@ class QueuePurge(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 4 + len(self.queue)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueuePurge
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueuePurge
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -2712,7 +2516,7 @@ class QueuePurge(AMQPMethodPayload):
offset += 0
no_wait = bool(_bit >> 0)
offset += 1
- return QueuePurge(queue, no_wait)
+ return cls(queue, no_wait)
class QueuePurgeOk(AMQPMethodPayload):
@@ -2720,6 +2524,8 @@ class QueuePurgeOk(AMQPMethodPayload):
Confirms a queue purge
This method confirms the purge of a queue.
+ :param message_count: Reports the number of messages purged.
+ :type message_count: int, 32 bit unsigned (message-count in AMQP)
"""
__slots__ = (u'message_count', )
@@ -2734,24 +2540,21 @@ class QueuePurgeOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'message-count', u'message-count', u'long', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'QueuePurgeOk(%s)' % (', '.join(map(repr,
- [self.message_count])))
+ return 'QueuePurgeOk(%s)' % (', '.join(map(repr, [self.message_count])))
def __init__(self, message_count):
"""
Create frame queue.purge-ok
-
- :param message_count: Reports the number of messages purged.
- :type message_count: int, 32 bit unsigned (message-count in AMQP)
"""
self.message_count = message_count
@@ -2761,12 +2564,12 @@ class QueuePurgeOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 4
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueuePurgeOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueuePurgeOk
offset = start_offset
message_count, = struct.unpack_from('!I', buf, offset)
offset += 4
- return QueuePurgeOk(message_count)
+ return cls(message_count)
class QueueUnbind(AMQPMethodPayload):
@@ -2774,13 +2577,18 @@ class QueueUnbind(AMQPMethodPayload):
Unbind a queue from an exchange
This method unbinds a queue from an exchange.
+ :param queue: Specifies the name of the queue to unbind.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :param exchange: The name of the exchange to unbind from.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Routing key of binding
+ Specifies the routing key of the binding to unbind.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
+ :param arguments: Arguments of binding
+ Specifies the arguments of the binding to unbind.
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
- __slots__ = (
- u'queue',
- u'exchange',
- u'routing_key',
- u'arguments',
- )
+ __slots__ = (u'queue', u'exchange', u'routing_key', u'arguments',)
NAME = u'queue.unbind'
@@ -2793,7 +2601,7 @@ class QueueUnbind(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'queue', u'queue-name', u'shortstr', reserved=False),
Field(u'exchange', u'exchange-name', u'shortstr', reserved=False),
@@ -2804,27 +2612,15 @@ class QueueUnbind(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'QueueUnbind(%s)' % (', '.join(
- map(repr,
- [self.queue, self.exchange, self.routing_key, self.arguments
- ])))
+ return 'QueueUnbind(%s)' % (
+ ', '.join(map(repr, [self.queue, self.exchange, self.routing_key, self.arguments])))
def __init__(self, queue, exchange, routing_key, arguments):
"""
Create frame queue.unbind
-
- :param queue: Specifies the name of the queue to unbind.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :param exchange: The name of the exchange to unbind from.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Routing key of binding
- Specifies the routing key of the binding to unbind.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
- :param arguments: Arguments of binding
- Specifies the arguments of the binding to unbind.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
self.queue = queue
self.exchange = exchange
@@ -2842,11 +2638,11 @@ class QueueUnbind(AMQPMethodPayload):
enframe_table(buf, self.arguments)
def get_size(self): # type: () -> int
- return 5 + len(self.queue) + len(self.exchange) + len(
- self.routing_key) + frame_table_size(self.arguments)
+ return 5 + len(self.queue) + len(self.exchange) + len(self.routing_key) + frame_table_size(
+ self.arguments)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueUnbind
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueUnbind
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -2862,7 +2658,7 @@ class QueueUnbind(AMQPMethodPayload):
offset += s_len
arguments, delta = deframe_table(buf, offset)
offset += delta
- return QueueUnbind(queue, exchange, routing_key, arguments)
+ return cls(queue, exchange, routing_key, arguments)
class QueueUnbindOk(AMQPMethodPayload):
@@ -2887,19 +2683,15 @@ class QueueUnbindOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'QueueUnbindOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame queue.unbind-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> QueueUnbindOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> QueueUnbindOk
offset = start_offset
- return QueueUnbindOk()
+ return cls()
class Basic(AMQPClass):
@@ -2971,14 +2763,13 @@ class BasicContentPropertyList(AMQPContentPropertyList):
:type reserved: binary type (max length 255) (AMQP as shortstr)
"""
zpf = bytearray([
- (('content_type' in kwargs) << 7) |
- (('content_encoding' in kwargs) << 6) |
- (('headers' in kwargs) << 5) | (('delivery_mode' in kwargs) << 4) |
- (('priority' in kwargs) << 3) | (('correlation_id' in kwargs) << 2)
- | (('reply_to' in kwargs) << 1) | int('expiration' in kwargs),
- (('message_id' in kwargs) << 7) | (('timestamp' in kwargs) << 6) |
- (('type_' in kwargs) << 5) | (('user_id' in kwargs) << 4) |
- (('app_id' in kwargs) << 3) | (('reserved' in kwargs) << 2)
+ (('content_type' in kwargs) << 7) | (('content_encoding' in kwargs) << 6) | (
+ ('headers' in kwargs) << 5) | (('delivery_mode' in kwargs) << 4) | (
+ ('priority' in kwargs) << 3) | (('correlation_id' in kwargs) << 2) | (
+ ('reply_to' in kwargs) << 1) | int('expiration' in kwargs),
+ (('message_id' in kwargs) << 7) | (('timestamp' in kwargs) << 6) | (
+ ('type_' in kwargs) << 5) | (('user_id' in kwargs) << 4) | (
+ ('app_id' in kwargs) << 3) | (('reserved' in kwargs) << 2)
])
zpf = six.binary_type(zpf)
@@ -3002,41 +2793,35 @@ class BasicContentPropertyList(AMQPContentPropertyList):
if zpf in BasicContentPropertyList.PARTICULAR_CLASSES:
return BasicContentPropertyList.PARTICULAR_CLASSES[zpf](**kwargs)
else:
- logger.debug(
- 'Property field (BasicContentPropertyList:%s) not seen yet, compiling',
- repr(zpf))
- c = compile_particular_content_property_list_class(
- zpf, BasicContentPropertyList.FIELDS)
+ logger.debug('Property field (BasicContentPropertyList:%s) not seen yet, compiling',
+ repr(zpf))
+ c = compile_particular_content_property_list_class(zpf, BasicContentPropertyList.FIELDS)
BasicContentPropertyList.PARTICULAR_CLASSES[zpf] = c
return c(**kwargs)
@staticmethod
def typize(*fields): # type: (*str) -> type
zpf = bytearray([
- (('content_type' in fields) << 7) |
- (('content_encoding' in fields) << 6) |
- (('headers' in fields) << 5) | (('delivery_mode' in fields) << 4) |
- (('priority' in fields) << 3) | (('correlation_id' in fields) << 2)
- | (('reply_to' in fields) << 1) | int('expiration' in kwargs),
- (('message_id' in fields) << 7) | (('timestamp' in fields) << 6) |
- (('type_' in fields) << 5) | (('user_id' in fields) << 4) |
- (('app_id' in fields) << 3) | (('reserved' in fields) << 2)
+ (('content_type' in fields) << 7) | (('content_encoding' in fields) << 6) | (
+ ('headers' in fields) << 5) | (('delivery_mode' in fields) << 4) | (
+ ('priority' in fields) << 3) | (('correlation_id' in fields) << 2) | (
+ ('reply_to' in fields) << 1) | int('expiration' in kwargs),
+ (('message_id' in fields) << 7) | (('timestamp' in fields) << 6) | (
+ ('type_' in fields) << 5) | (('user_id' in fields) << 4) | (
+ ('app_id' in fields) << 3) | (('reserved' in fields) << 2)
])
zpf = six.binary_type(zpf)
if zpf in BasicContentPropertyList.PARTICULAR_CLASSES:
return BasicContentPropertyList.PARTICULAR_CLASSES[zpf]
else:
- logger.debug(
- 'Property field (BasicContentPropertyList:%s) not seen yet, compiling',
- repr(zpf))
- c = compile_particular_content_property_list_class(
- zpf, BasicContentPropertyList.FIELDS)
+ logger.debug('Property field (BasicContentPropertyList:%s) not seen yet, compiling',
+ repr(zpf))
+ c = compile_particular_content_property_list_class(zpf, BasicContentPropertyList.FIELDS)
BasicContentPropertyList.PARTICULAR_CLASSES[zpf] = c
return c
@staticmethod
- def from_buffer(buf,
- offset): # type: (buffer, int) -> BasicContentPropertyList
+ def from_buffer(buf, offset): # type: (buffer, int) -> BasicContentPropertyList
"""
Return a content property list instance unserialized from
buffer, so that buf[offset] marks the start of property flags
@@ -3049,17 +2834,13 @@ class BasicContentPropertyList(AMQPContentPropertyList):
else:
while buf[offset + pfl - 1] & 1:
pfl += 2
- zpf = BasicContentPropertyList.zero_property_flags(buf[offset:offset +
- pfl]).tobytes()
+ zpf = BasicContentPropertyList.zero_property_flags(buf[offset:offset + pfl]).tobytes()
if zpf in BasicContentPropertyList.PARTICULAR_CLASSES:
- return BasicContentPropertyList.PARTICULAR_CLASSES[
- zpf].from_buffer(buf, offset)
+ return BasicContentPropertyList.PARTICULAR_CLASSES[zpf].from_buffer(buf, offset)
else:
- logger.debug(
- 'Property field (BasicContentPropertyList:%s) not seen yet, compiling',
- repr(zpf))
- c = compile_particular_content_property_list_class(
- zpf, BasicContentPropertyList.FIELDS)
+ logger.debug('Property field (BasicContentPropertyList:%s) not seen yet, compiling',
+ repr(zpf))
+ c = compile_particular_content_property_list_class(zpf, BasicContentPropertyList.FIELDS)
BasicContentPropertyList.PARTICULAR_CLASSES[zpf] = c
return c.from_buffer(buf, offset)
@@ -3075,11 +2856,17 @@ class BasicAck(AMQPMethodPayload):
confirm mode.
The acknowledgement can be for a single message or a set of
messages up to and including a specific message.
+ :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
+ :param multiple: Acknowledge multiple messages
+ If set to 1, the delivery tag is treated as "up to and
+ including", so that multiple messages can be acknowledged
+ with a single method. If set to zero, the delivery tag
+ refers to a single message. If the multiple field is 1, and
+ the delivery tag is zero, this indicates acknowledgement of
+ all outstanding messages.
+ :type multiple: bool (bit in AMQP)
"""
- __slots__ = (
- u'delivery_tag',
- u'multiple',
- )
+ __slots__ = (u'delivery_tag', u'multiple',)
NAME = u'basic.ack'
@@ -3092,7 +2879,7 @@ class BasicAck(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'delivery-tag', u'delivery-tag', u'longlong', reserved=False),
Field(u'multiple', u'bit', u'bit', reserved=False),
]
@@ -3100,24 +2887,14 @@ class BasicAck(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicAck(%s)' % (', '.join(
- map(repr, [self.delivery_tag, self.multiple])))
+ return 'BasicAck(%s)' % (', '.join(map(repr, [self.delivery_tag, self.multiple])))
def __init__(self, delivery_tag, multiple):
"""
Create frame basic.ack
-
- :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
- :param multiple: Acknowledge multiple messages
- If set to 1, the delivery tag is treated as "up to and
- including", so that multiple messages can be acknowledged
- with a single method. If set to zero, the delivery tag
- refers to a single message. If the multiple field is 1, and
- the delivery tag is zero, this indicates acknowledgement of
- all outstanding messages.
- :type multiple: bool (bit in AMQP)
"""
self.delivery_tag = delivery_tag
self.multiple = multiple
@@ -3128,14 +2905,14 @@ class BasicAck(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 9
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicAck
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicAck
offset = start_offset
delivery_tag, _bit, = struct.unpack_from('!QB', buf, offset)
offset += 8
multiple = bool(_bit >> 0)
offset += 1
- return BasicAck(delivery_tag, multiple)
+ return cls(delivery_tag, multiple)
class BasicConsume(AMQPMethodPayload):
@@ -3147,16 +2924,30 @@ class BasicConsume(AMQPMethodPayload):
messages from a specific queue. Consumers last as long as the
channel they were
declared on, or until the client cancels them.
+ :param queue: Specifies the name of the queue to consume from.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :param consumer_tag: Specifies the identifier for the consumer. the consumer tag
+ is local to a
+ channel, so two clients can use the same consumer tags. If
+ this field is
+ empty the server will generate a unique tag.
+ :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
+ :type no_local: bool (no-local in AMQP)
+ :type no_ack: bool (no-ack in AMQP)
+ :param exclusive: Request exclusive access
+ Request exclusive consumer access, meaning only this
+ consumer can access the
+ queue.
+ :type exclusive: bool (bit in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
+ :param arguments: Arguments for declaration
+ A set of arguments for the consume. The syntax and semantics
+ of these
+ arguments depends on the server implementation.
+ :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
__slots__ = (
- u'queue',
- u'consumer_tag',
- u'no_local',
- u'no_ack',
- u'exclusive',
- u'no_wait',
- u'arguments',
- )
+ u'queue', u'consumer_tag', u'no_local', u'no_ack', u'exclusive', u'no_wait', u'arguments',)
NAME = u'basic.consume'
@@ -3183,40 +2974,17 @@ class BasicConsume(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicConsume(%s)' % (', '.join(
- map(repr, [
- self.queue, self.consumer_tag, self.no_local, self.no_ack,
- self.exclusive, self.no_wait, self.arguments
- ])))
+ return 'BasicConsume(%s)' % (', '.join(map(repr,
+ [self.queue, self.consumer_tag, self.no_local,
+ self.no_ack, self.exclusive, self.no_wait,
+ self.arguments])))
- def __init__(self, queue, consumer_tag, no_local, no_ack, exclusive,
- no_wait, arguments):
+ def __init__(self, queue, consumer_tag, no_local, no_ack, exclusive, no_wait, arguments):
"""
Create frame basic.consume
-
- :param queue: Specifies the name of the queue to consume from.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :param consumer_tag: Specifies the identifier for the consumer. the consumer tag
- is local to a
- channel, so two clients can use the same consumer tags. If
- this field is
- empty the server will generate a unique tag.
- :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
- :type no_local: bool (no-local in AMQP)
- :type no_ack: bool (no-ack in AMQP)
- :param exclusive: Request exclusive access
- Request exclusive consumer access, meaning only this
- consumer can access the
- queue.
- :type exclusive: bool (bit in AMQP)
- :type no_wait: bool (no-wait in AMQP)
- :param arguments: Arguments for declaration
- A set of arguments for the consume. The syntax and semantics
- of these
- arguments depends on the server implementation.
- :type arguments: table. See coolamqp.uplink.framing.field_table (table in AMQP)
"""
self.queue = queue
self.consumer_tag = consumer_tag
@@ -3232,17 +3000,16 @@ class BasicConsume(AMQPMethodPayload):
buf.write(self.queue)
buf.write(struct.pack('!B', len(self.consumer_tag)))
buf.write(self.consumer_tag)
- buf.write(
- struct.pack('!B', (self.no_local << 0) | (self.no_ack << 1) |
- (self.exclusive << 2) | (self.no_wait << 3)))
+ buf.write(struct.pack('!B',
+ (self.no_local << 0) | (self.no_ack << 1) | (self.exclusive << 2) | (
+ self.no_wait << 3)))
enframe_table(buf, self.arguments)
def get_size(self): # type: () -> int
- return 5 + len(self.queue) + len(self.consumer_tag) + frame_table_size(
- self.arguments)
+ return 5 + len(self.queue) + len(self.consumer_tag) + frame_table_size(self.arguments)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicConsume
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicConsume
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -3261,8 +3028,7 @@ class BasicConsume(AMQPMethodPayload):
offset += 1
arguments, delta = deframe_table(buf, offset)
offset += delta
- return BasicConsume(queue, consumer_tag, no_local, no_ack, exclusive,
- no_wait, arguments)
+ return cls(queue, consumer_tag, no_local, no_ack, exclusive, no_wait, arguments)
class BasicCancel(AMQPMethodPayload):
@@ -3287,11 +3053,10 @@ class BasicCancel(AMQPMethodPayload):
for the broker to be able to identify those clients that are
capable of accepting the method, through some means of
capability negotiation.
+ :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
+ :type no_wait: bool (no-wait in AMQP)
"""
- __slots__ = (
- u'consumer_tag',
- u'no_wait',
- )
+ __slots__ = (u'consumer_tag', u'no_wait',)
NAME = u'basic.cancel'
@@ -3304,7 +3069,7 @@ class BasicCancel(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'consumer-tag', u'consumer-tag', u'shortstr', reserved=False),
Field(u'no-wait', u'no-wait', u'bit', reserved=False),
]
@@ -3312,17 +3077,14 @@ class BasicCancel(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicCancel(%s)' % (', '.join(
- map(repr, [self.consumer_tag, self.no_wait])))
+ return 'BasicCancel(%s)' % (', '.join(map(repr, [self.consumer_tag, self.no_wait])))
def __init__(self, consumer_tag, no_wait):
"""
Create frame basic.cancel
-
- :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
- :type no_wait: bool (no-wait in AMQP)
"""
self.consumer_tag = consumer_tag
self.no_wait = no_wait
@@ -3335,8 +3097,8 @@ class BasicCancel(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 2 + len(self.consumer_tag)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicCancel
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicCancel
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
@@ -3346,7 +3108,7 @@ class BasicCancel(AMQPMethodPayload):
offset += 0
no_wait = bool(_bit >> 0)
offset += 1
- return BasicCancel(consumer_tag, no_wait)
+ return cls(consumer_tag, no_wait)
class BasicConsumeOk(AMQPMethodPayload):
@@ -3356,6 +3118,9 @@ class BasicConsumeOk(AMQPMethodPayload):
The server provides the client with a consumer tag, which is
used by the client
for methods called on the consumer at a later stage.
+ :param consumer_tag: Holds the consumer tag specified by the client or provided
+ by the server.
+ :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
"""
__slots__ = (u'consumer_tag', )
@@ -3370,25 +3135,21 @@ class BasicConsumeOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'consumer-tag', u'consumer-tag', u'shortstr', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicConsumeOk(%s)' % (', '.join(map(repr,
- [self.consumer_tag])))
+ return 'BasicConsumeOk(%s)' % (', '.join(map(repr, [self.consumer_tag])))
def __init__(self, consumer_tag):
"""
Create frame basic.consume-ok
-
- :param consumer_tag: Holds the consumer tag specified by the client or provided
- by the server.
- :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
"""
self.consumer_tag = consumer_tag
@@ -3399,15 +3160,14 @@ class BasicConsumeOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1 + len(self.consumer_tag)
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> BasicConsumeOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicConsumeOk
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
consumer_tag = buf[offset:offset + s_len]
offset += s_len
- return BasicConsumeOk(consumer_tag)
+ return cls(consumer_tag)
class BasicCancelOk(AMQPMethodPayload):
@@ -3415,6 +3175,7 @@ class BasicCancelOk(AMQPMethodPayload):
Confirm a cancelled consumer
This method confirms that the cancellation was completed.
+ :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
"""
__slots__ = (u'consumer_tag', )
@@ -3429,23 +3190,21 @@ class BasicCancelOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'consumer-tag', u'consumer-tag', u'shortstr', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicCancelOk(%s)' % (', '.join(map(repr,
- [self.consumer_tag])))
+ return 'BasicCancelOk(%s)' % (', '.join(map(repr, [self.consumer_tag])))
def __init__(self, consumer_tag):
"""
Create frame basic.cancel-ok
-
- :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
"""
self.consumer_tag = consumer_tag
@@ -3456,14 +3215,14 @@ class BasicCancelOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1 + len(self.consumer_tag)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicCancelOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicCancelOk
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
consumer_tag = buf[offset:offset + s_len]
offset += s_len
- return BasicCancelOk(consumer_tag)
+ return cls(consumer_tag)
class BasicDeliver(AMQPMethodPayload):
@@ -3477,14 +3236,19 @@ class BasicDeliver(AMQPMethodPayload):
the server responds with Deliver methods as and when messages
arrive for that
consumer.
+ :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
+ :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
+ :type redelivered: bool (redelivered in AMQP)
+ :param exchange: Specifies the name of the exchange that the message was
+ originally published to.
+ May be empty, indicating the default exchange.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Message routing key
+ Specifies the routing key name specified when the message
+ was published.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
"""
- __slots__ = (
- u'consumer_tag',
- u'delivery_tag',
- u'redelivered',
- u'exchange',
- u'routing_key',
- )
+ __slots__ = (u'consumer_tag', u'delivery_tag', u'redelivered', u'exchange', u'routing_key',)
NAME = u'basic.deliver'
@@ -3497,7 +3261,7 @@ class BasicDeliver(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'consumer-tag', u'consumer-tag', u'shortstr', reserved=False),
Field(u'delivery-tag', u'delivery-tag', u'longlong', reserved=False),
Field(u'redelivered', u'redelivered', u'bit', reserved=False),
@@ -3508,30 +3272,16 @@ class BasicDeliver(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicDeliver(%s)' % (', '.join(
- map(repr, [
- self.consumer_tag, self.delivery_tag, self.redelivered,
- self.exchange, self.routing_key
- ])))
+ return 'BasicDeliver(%s)' % (', '.join(map(repr, [self.consumer_tag, self.delivery_tag,
+ self.redelivered, self.exchange,
+ self.routing_key])))
- def __init__(self, consumer_tag, delivery_tag, redelivered, exchange,
- routing_key):
+ def __init__(self, consumer_tag, delivery_tag, redelivered, exchange, routing_key):
"""
Create frame basic.deliver
-
- :type consumer_tag: binary type (max length 255) (consumer-tag in AMQP)
- :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
- :type redelivered: bool (redelivered in AMQP)
- :param exchange: Specifies the name of the exchange that the message was
- originally published to.
- May be empty, indicating the default exchange.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Message routing key
- Specifies the routing key name specified when the message
- was published.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
"""
self.consumer_tag = consumer_tag
self.delivery_tag = delivery_tag
@@ -3543,18 +3293,16 @@ class BasicDeliver(AMQPMethodPayload):
buf.write(struct.pack('!B', len(self.consumer_tag)))
buf.write(self.consumer_tag)
buf.write(
- struct.pack('!QBB', self.delivery_tag, (self.redelivered << 0),
- len(self.exchange)))
+ struct.pack('!QBB', self.delivery_tag, (self.redelivered << 0), len(self.exchange)))
buf.write(self.exchange)
buf.write(struct.pack('!B', len(self.routing_key)))
buf.write(self.routing_key)
def get_size(self): # type: () -> int
- return 12 + len(self.consumer_tag) + len(self.exchange) + len(
- self.routing_key)
+ return 12 + len(self.consumer_tag) + len(self.exchange) + len(self.routing_key)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicDeliver
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicDeliver
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
@@ -3572,8 +3320,7 @@ class BasicDeliver(AMQPMethodPayload):
offset += 1
routing_key = buf[offset:offset + s_len]
offset += s_len
- return BasicDeliver(consumer_tag, delivery_tag, redelivered, exchange,
- routing_key)
+ return cls(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
class BasicGet(AMQPMethodPayload):
@@ -3585,11 +3332,11 @@ class BasicGet(AMQPMethodPayload):
dialogue that is designed for specific types of application
where synchronous
functionality is more important than performance.
+ :param queue: Specifies the name of the queue to get a message from.
+ :type queue: binary type (max length 255) (queue-name in AMQP)
+ :type no_ack: bool (no-ack in AMQP)
"""
- __slots__ = (
- u'queue',
- u'no_ack',
- )
+ __slots__ = (u'queue', u'no_ack',)
NAME = u'basic.get'
@@ -3602,7 +3349,7 @@ class BasicGet(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'short', u'short', reserved=True),
Field(u'queue', u'queue-name', u'shortstr', reserved=False),
Field(u'no-ack', u'no-ack', u'bit', reserved=False),
@@ -3611,18 +3358,14 @@ class BasicGet(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicGet(%s)' % (', '.join(map(repr,
- [self.queue, self.no_ack])))
+ return 'BasicGet(%s)' % (', '.join(map(repr, [self.queue, self.no_ack])))
def __init__(self, queue, no_ack):
"""
Create frame basic.get
-
- :param queue: Specifies the name of the queue to get a message from.
- :type queue: binary type (max length 255) (queue-name in AMQP)
- :type no_ack: bool (no-ack in AMQP)
"""
self.queue = queue
self.no_ack = no_ack
@@ -3636,8 +3379,8 @@ class BasicGet(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 4 + len(self.queue)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicGet
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicGet
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -3647,7 +3390,7 @@ class BasicGet(AMQPMethodPayload):
offset += 0
no_ack = bool(_bit >> 0)
offset += 1
- return BasicGet(queue, no_ack)
+ return cls(queue, no_ack)
class BasicGetOk(AMQPMethodPayload):
@@ -3659,14 +3402,19 @@ class BasicGetOk(AMQPMethodPayload):
delivered by 'get-ok' must be acknowledged unless the no-ack
option was set in the
get method.
+ :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
+ :type redelivered: bool (redelivered in AMQP)
+ :param exchange: Specifies the name of the exchange that the message was
+ originally published to.
+ If empty, the message was published to the default exchange.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Message routing key
+ Specifies the routing key name specified when the message
+ was published.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
+ :type message_count: int, 32 bit unsigned (message-count in AMQP)
"""
- __slots__ = (
- u'delivery_tag',
- u'redelivered',
- u'exchange',
- u'routing_key',
- u'message_count',
- )
+ __slots__ = (u'delivery_tag', u'redelivered', u'exchange', u'routing_key', u'message_count',)
NAME = u'basic.get-ok'
@@ -3679,7 +3427,7 @@ class BasicGetOk(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'delivery-tag', u'delivery-tag', u'longlong', reserved=False),
Field(u'redelivered', u'redelivered', u'bit', reserved=False),
Field(u'exchange', u'exchange-name', u'shortstr', reserved=False),
@@ -3690,30 +3438,16 @@ class BasicGetOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicGetOk(%s)' % (', '.join(
- map(repr, [
- self.delivery_tag, self.redelivered, self.exchange,
- self.routing_key, self.message_count
- ])))
+ return 'BasicGetOk(%s)' % (', '.join(map(repr, [self.delivery_tag, self.redelivered,
+ self.exchange, self.routing_key,
+ self.message_count])))
- def __init__(self, delivery_tag, redelivered, exchange, routing_key,
- message_count):
+ def __init__(self, delivery_tag, redelivered, exchange, routing_key, message_count):
"""
Create frame basic.get-ok
-
- :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
- :type redelivered: bool (redelivered in AMQP)
- :param exchange: Specifies the name of the exchange that the message was
- originally published to.
- If empty, the message was published to the default exchange.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Message routing key
- Specifies the routing key name specified when the message
- was published.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
- :type message_count: int, 32 bit unsigned (message-count in AMQP)
"""
self.delivery_tag = delivery_tag
self.redelivered = redelivered
@@ -3723,8 +3457,7 @@ class BasicGetOk(AMQPMethodPayload):
def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
buf.write(
- struct.pack('!QBB', self.delivery_tag, (self.redelivered << 0),
- len(self.exchange)))
+ struct.pack('!QBB', self.delivery_tag, (self.redelivered << 0), len(self.exchange)))
buf.write(self.exchange)
buf.write(struct.pack('!B', len(self.routing_key)))
buf.write(self.routing_key)
@@ -3733,8 +3466,8 @@ class BasicGetOk(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 15 + len(self.exchange) + len(self.routing_key)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicGetOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicGetOk
offset = start_offset
delivery_tag, _bit, = struct.unpack_from('!QB', buf, offset)
offset += 8
@@ -3750,8 +3483,7 @@ class BasicGetOk(AMQPMethodPayload):
offset += s_len
message_count, = struct.unpack_from('!I', buf, offset)
offset += 4
- return BasicGetOk(delivery_tag, redelivered, exchange, routing_key,
- message_count)
+ return cls(delivery_tag, redelivered, exchange, routing_key, message_count)
class BasicGetEmpty(AMQPMethodPayload):
@@ -3776,29 +3508,25 @@ class BasicGetEmpty(AMQPMethodPayload):
STATIC_CONTENT = b'\x00\x00\x00\x0D\x00\x3C\x00\x48\x00\xCE' # spans LENGTH, CLASS ID, METHOD ID, ....., FRAME_END
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reserved-1', u'shortstr', u'shortstr', reserved=True),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'BasicGetEmpty(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame basic.get-empty
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicGetEmpty
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicGetEmpty
offset = start_offset
s_len, = struct.unpack_from('!B', buf, offset)
offset += 1
offset += s_len # reserved field!
- return BasicGetEmpty()
+ return cls()
class BasicNack(AMQPMethodPayload):
@@ -3815,12 +3543,24 @@ class BasicNack(AMQPMethodPayload):
confirm mode of unhandled messages. If a publisher receives this
method, it
probably needs to republish the offending messages.
+ :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
+ :param multiple: Reject multiple messages
+ If set to 1, the delivery tag is treated as "up to and
+ including", so that multiple messages can be rejected
+ with a single method. If set to zero, the delivery tag
+ refers to a single message. If the multiple field is 1, and
+ the delivery tag is zero, this indicates rejection of
+ all outstanding messages.
+ :type multiple: bool (bit in AMQP)
+ :param requeue: Requeue the message
+ If requeue is true, the server will attempt to requeue the
+ message. If requeue
+ is false or the requeue attempt fails the messages are
+ discarded or dead-lettered.
+ Clients receiving the Nack methods should ignore this flag.
+ :type requeue: bool (bit in AMQP)
"""
- __slots__ = (
- u'delivery_tag',
- u'multiple',
- u'requeue',
- )
+ __slots__ = (u'delivery_tag', u'multiple', u'requeue',)
NAME = u'basic.nack'
@@ -3833,7 +3573,7 @@ class BasicNack(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'delivery-tag', u'delivery-tag', u'longlong', reserved=False),
Field(u'multiple', u'bit', u'bit', reserved=False),
Field(u'requeue', u'bit', u'bit', reserved=False),
@@ -3842,53 +3582,35 @@ class BasicNack(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicNack(%s)' % (', '.join(
- map(repr, [self.delivery_tag, self.multiple, self.requeue])))
+ return 'BasicNack(%s)' % (
+ ', '.join(map(repr, [self.delivery_tag, self.multiple, self.requeue])))
def __init__(self, delivery_tag, multiple, requeue):
"""
Create frame basic.nack
-
- :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
- :param multiple: Reject multiple messages
- If set to 1, the delivery tag is treated as "up to and
- including", so that multiple messages can be rejected
- with a single method. If set to zero, the delivery tag
- refers to a single message. If the multiple field is 1, and
- the delivery tag is zero, this indicates rejection of
- all outstanding messages.
- :type multiple: bool (bit in AMQP)
- :param requeue: Requeue the message
- If requeue is true, the server will attempt to requeue the
- message. If requeue
- is false or the requeue attempt fails the messages are
- discarded or dead-lettered.
- Clients receiving the Nack methods should ignore this flag.
- :type requeue: bool (bit in AMQP)
"""
self.delivery_tag = delivery_tag
self.multiple = multiple
self.requeue = requeue
def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
- buf.write(
- struct.pack('!QB', self.delivery_tag,
- (self.multiple << 0) | (self.requeue << 1)))
+ buf.write(struct.pack('!QB', self.delivery_tag, (self.multiple << 0) | (self.requeue << 1)))
def get_size(self): # type: () -> int
return 9
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicNack
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicNack
offset = start_offset
delivery_tag, _bit, = struct.unpack_from('!QB', buf, offset)
offset += 8
multiple = bool(_bit >> 0)
requeue = bool(_bit >> 1)
offset += 1
- return BasicNack(delivery_tag, multiple, requeue)
+ return cls(delivery_tag, multiple, requeue)
class BasicPublish(AMQPMethodPayload):
@@ -3900,13 +3622,38 @@ class BasicPublish(AMQPMethodPayload):
to queues as defined by the exchange configuration and
distributed to any active
consumers when the transaction, if any, is committed.
+ :param exchange: Specifies the name of the exchange to publish to. the
+ exchange name can be
+ empty, meaning the default exchange. If the exchange name is
+ specified, and that
+ exchange does not exist, the server will raise a channel
+ exception.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Message routing key
+ Specifies the routing key for the message. The routing key
+ is used for routing
+ messages depending on the exchange configuration.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
+ :param mandatory: Indicate mandatory routing
+ This flag tells the server how to react if the message
+ cannot be routed to a
+ queue. If this flag is set, the server will return an
+ unroutable message with a
+ Return method. If this flag is zero, the server silently
+ drops the message.
+ :type mandatory: bool (bit in AMQP)
+ :param immediate: Request immediate delivery
+ This flag tells the server how to react if the message
+ cannot be routed to a
+ queue consumer immediately. If this flag is set, the server
+ will return an
+ undeliverable message with a Return method. If this flag is
+ zero, the server
+ will queue the message, but with no guarantee that it will
+ ever be consumed.
+ :type immediate: bool (bit in AMQP)
"""
- __slots__ = (
- u'exchange',
- u'routing_key',
- u'mandatory',
- u'immediate',
- )
+ __slots__ = (u'exchange', u'routing_key', u'mandatory', u'immediate',)
NAME = u'basic.publish'
@@ -3930,47 +3677,15 @@ class BasicPublish(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicPublish(%s)' % (', '.join(
- map(repr, [
- self.exchange, self.routing_key, self.mandatory, self.immediate
- ])))
+ return 'BasicPublish(%s)' % (
+ ', '.join(map(repr, [self.exchange, self.routing_key, self.mandatory, self.immediate])))
def __init__(self, exchange, routing_key, mandatory, immediate):
"""
Create frame basic.publish
-
- :param exchange: Specifies the name of the exchange to publish to. the
- exchange name can be
- empty, meaning the default exchange. If the exchange name is
- specified, and that
- exchange does not exist, the server will raise a channel
- exception.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Message routing key
- Specifies the routing key for the message. The routing key
- is used for routing
- messages depending on the exchange configuration.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
- :param mandatory: Indicate mandatory routing
- This flag tells the server how to react if the message
- cannot be routed to a
- queue. If this flag is set, the server will return an
- unroutable message with a
- Return method. If this flag is zero, the server silently
- drops the message.
- :type mandatory: bool (bit in AMQP)
- :param immediate: Request immediate delivery
- This flag tells the server how to react if the message
- cannot be routed to a
- queue consumer immediately. If this flag is set, the server
- will return an
- undeliverable message with a Return method. If this flag is
- zero, the server
- will queue the message, but with no guarantee that it will
- ever be consumed.
- :type immediate: bool (bit in AMQP)
"""
self.exchange = exchange
self.routing_key = routing_key
@@ -3983,14 +3698,13 @@ class BasicPublish(AMQPMethodPayload):
buf.write(self.exchange)
buf.write(struct.pack('!B', len(self.routing_key)))
buf.write(self.routing_key)
- buf.write(
- struct.pack('!B', (self.mandatory << 0) | (self.immediate << 1)))
+ buf.write(struct.pack('!B', (self.mandatory << 0) | (self.immediate << 1)))
def get_size(self): # type: () -> int
return 5 + len(self.exchange) + len(self.routing_key)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicPublish
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicPublish
offset = start_offset
s_len, = struct.unpack_from('!2xB', buf, offset)
offset += 3
@@ -4005,7 +3719,7 @@ class BasicPublish(AMQPMethodPayload):
mandatory = bool(_bit >> 0)
immediate = bool(_bit >> 1)
offset += 1
- return BasicPublish(exchange, routing_key, mandatory, immediate)
+ return cls(exchange, routing_key, mandatory, immediate)
class BasicQos(AMQPMethodPayload):
@@ -4021,44 +3735,7 @@ class BasicQos(AMQPMethodPayload):
qos method could in principle apply to both peers, it is
currently meaningful only
for the server.
- """
- __slots__ = (
- u'prefetch_size',
- u'prefetch_count',
- u'global_',
- )
-
- NAME = u'basic.qos'
-
- INDEX = (60, 10) # (Class ID, Method ID)
- BINARY_HEADER = b'\x00\x3C\x00\x0A' # CLASS ID + METHOD ID
-
- SENT_BY_CLIENT, SENT_BY_SERVER = False, True
-
- IS_SIZE_STATIC = True # this means that argument part has always the same length
- IS_CONTENT_STATIC = False # this means that argument part has always the same content
-
- # See constructor pydoc for details
- FIELDS = [
- Field(u'prefetch-size', u'long', u'long', reserved=False),
- Field(u'prefetch-count', u'short', u'short', reserved=False),
- Field(u'global', u'bit', u'bit', reserved=False),
- ]
-
- def __repr__(self): # type: () -> str
- """
- Convert the frame to a Python-representable string
- :return: Python string representation
- """
- return 'BasicQos(%s)' % (', '.join(
- map(repr,
- [self.prefetch_size, self.prefetch_count, self.global_])))
-
- def __init__(self, prefetch_size, prefetch_count, global_):
- """
- Create frame basic.qos
-
- :param prefetch_size: Prefetch window in octets
+ :param prefetch_size: Prefetch window in octets
The client can request that messages be sent in advance so
that when the client
finishes processing a message, the following message is
@@ -4075,8 +3752,8 @@ class BasicQos(AMQPMethodPayload):
prefetch limits may still
apply. The prefetch-size is ignored if the no-ack option is
set.
- :type prefetch_size: int, 32 bit unsigned (long in AMQP)
- :param prefetch_count: Prefetch window in messages
+ :type prefetch_size: int, 32 bit unsigned (long in AMQP)
+ :param prefetch_count: Prefetch window in messages
Specifies a prefetch window in terms of whole messages. This
field may be used
in combination with the prefetch-size field; a message will
@@ -4085,8 +3762,8 @@ class BasicQos(AMQPMethodPayload):
and connection level)
allow it. The prefetch-count is ignored if the no-ack option
is set.
- :type prefetch_count: int, 16 bit unsigned (short in AMQP)
- :param global_: Apply to entire connection
+ :type prefetch_count: int, 16 bit unsigned (short in AMQP)
+ :param global_: Apply to entire connection
RabbitMQ has reinterpreted this field. The original
specification said: "By default the QoS settings apply to
the current channel only. If this field is set, they are
@@ -4095,29 +3772,58 @@ class BasicQos(AMQPMethodPayload):
per-consumer (for new consumers on the channel; existing
ones being unaffected) and global=true to mean that the QoS
settings should apply per-channel.
- :type global_: bool (bit in AMQP)
+ :type global_: bool (bit in AMQP)
+ """
+ __slots__ = (u'prefetch_size', u'prefetch_count', u'global_',)
+
+ NAME = u'basic.qos'
+
+ INDEX = (60, 10) # (Class ID, Method ID)
+ BINARY_HEADER = b'\x00\x3C\x00\x0A' # CLASS ID + METHOD ID
+
+ SENT_BY_CLIENT, SENT_BY_SERVER = False, True
+
+ IS_SIZE_STATIC = True # this means that argument part has always the same length
+ IS_CONTENT_STATIC = False # this means that argument part has always the same content
+
+ # See constructor pydoc for details
+ FIELDS = [
+ Field(u'prefetch-size', u'long', u'long', reserved=False),
+ Field(u'prefetch-count', u'short', u'short', reserved=False),
+ Field(u'global', u'bit', u'bit', reserved=False),
+ ]
+
+ def __repr__(self): # type: () -> str
+ """
+ Convert the frame to a Python-representable string
+
+ :return: Python string representation
+ """
+ return 'BasicQos(%s)' % (
+ ', '.join(map(repr, [self.prefetch_size, self.prefetch_count, self.global_])))
+
+ def __init__(self, prefetch_size, prefetch_count, global_):
+ """
+ Create frame basic.qos
"""
self.prefetch_size = prefetch_size
self.prefetch_count = prefetch_count
self.global_ = global_
def write_arguments(self, buf): # type: (tp.BinaryIO) -> None
- buf.write(
- struct.pack('!IHB', self.prefetch_size, self.prefetch_count,
- (self.global_ << 0)))
+ buf.write(struct.pack('!IHB', self.prefetch_size, self.prefetch_count, (self.global_ << 0)))
def get_size(self): # type: () -> int
return 7
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicQos
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicQos
offset = start_offset
- prefetch_size, prefetch_count, _bit, = struct.unpack_from(
- '!IHB', buf, offset)
+ prefetch_size, prefetch_count, _bit, = struct.unpack_from('!IHB', buf, offset)
offset += 6
global_ = bool(_bit >> 0)
offset += 1
- return BasicQos(prefetch_size, prefetch_count, global_)
+ return cls(prefetch_size, prefetch_count, global_)
class BasicQosOk(AMQPMethodPayload):
@@ -4146,19 +3852,15 @@ class BasicQosOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'BasicQosOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame basic.qos-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicQosOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicQosOk
offset = start_offset
- return BasicQosOk()
+ return cls()
class BasicReturn(AMQPMethodPayload):
@@ -4172,13 +3874,18 @@ class BasicReturn(AMQPMethodPayload):
reply code and text provide information about the reason that
the message was
undeliverable.
+ :type reply_code: int, 16 bit unsigned (reply-code in AMQP)
+ :type reply_text: binary type (max length 255) (reply-text in AMQP)
+ :param exchange: Specifies the name of the exchange that the message was
+ originally published
+ to. May be empty, meaning the default exchange.
+ :type exchange: binary type (max length 255) (exchange-name in AMQP)
+ :param routing_key: Message routing key
+ Specifies the routing key name specified when the message
+ was published.
+ :type routing_key: binary type (max length 255) (shortstr in AMQP)
"""
- __slots__ = (
- u'reply_code',
- u'reply_text',
- u'exchange',
- u'routing_key',
- )
+ __slots__ = (u'reply_code', u'reply_text', u'exchange', u'routing_key',)
NAME = u'basic.return'
@@ -4191,7 +3898,7 @@ class BasicReturn(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'reply-code', u'reply-code', u'short', reserved=False),
Field(u'reply-text', u'reply-text', u'shortstr', reserved=False),
Field(u'exchange', u'exchange-name', u'shortstr', reserved=False),
@@ -4201,28 +3908,15 @@ class BasicReturn(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'BasicReturn(%s)' % (', '.join(
- map(repr, [
- self.reply_code, self.reply_text, self.exchange,
- self.routing_key
- ])))
+ map(repr, [self.reply_code, self.reply_text, self.exchange, self.routing_key])))
def __init__(self, reply_code, reply_text, exchange, routing_key):
"""
Create frame basic.return
-
- :type reply_code: int, 16 bit unsigned (reply-code in AMQP)
- :type reply_text: binary type (max length 255) (reply-text in AMQP)
- :param exchange: Specifies the name of the exchange that the message was
- originally published
- to. May be empty, meaning the default exchange.
- :type exchange: binary type (max length 255) (exchange-name in AMQP)
- :param routing_key: Message routing key
- Specifies the routing key name specified when the message
- was published.
- :type routing_key: binary type (max length 255) (shortstr in AMQP)
"""
self.reply_code = reply_code
self.reply_text = reply_text
@@ -4238,11 +3932,10 @@ class BasicReturn(AMQPMethodPayload):
buf.write(self.routing_key)
def get_size(self): # type: () -> int
- return 5 + len(self.reply_text) + len(self.exchange) + len(
- self.routing_key)
+ return 5 + len(self.reply_text) + len(self.exchange) + len(self.routing_key)
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicReturn
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicReturn
offset = start_offset
reply_code, s_len, = struct.unpack_from('!HB', buf, offset)
offset += 3
@@ -4256,7 +3949,7 @@ class BasicReturn(AMQPMethodPayload):
offset += 1
routing_key = buf[offset:offset + s_len]
offset += s_len
- return BasicReturn(reply_code, reply_text, exchange, routing_key)
+ return cls(reply_code, reply_text, exchange, routing_key)
class BasicReject(AMQPMethodPayload):
@@ -4268,11 +3961,15 @@ class BasicReject(AMQPMethodPayload):
cancel large incoming messages, or return untreatable messages
to their original
queue.
+ :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
+ :param requeue: Requeue the message
+ If requeue is true, the server will attempt to requeue the
+ message. If requeue
+ is false or the requeue attempt fails the messages are
+ discarded or dead-lettered.
+ :type requeue: bool (bit in AMQP)
"""
- __slots__ = (
- u'delivery_tag',
- u'requeue',
- )
+ __slots__ = (u'delivery_tag', u'requeue',)
NAME = u'basic.reject'
@@ -4285,7 +3982,7 @@ class BasicReject(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'delivery-tag', u'delivery-tag', u'longlong', reserved=False),
Field(u'requeue', u'bit', u'bit', reserved=False),
]
@@ -4293,22 +3990,14 @@ class BasicReject(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
- return 'BasicReject(%s)' % (', '.join(
- map(repr, [self.delivery_tag, self.requeue])))
+ return 'BasicReject(%s)' % (', '.join(map(repr, [self.delivery_tag, self.requeue])))
def __init__(self, delivery_tag, requeue):
"""
Create frame basic.reject
-
- :type delivery_tag: int, 64 bit unsigned (delivery-tag in AMQP)
- :param requeue: Requeue the message
- If requeue is true, the server will attempt to requeue the
- message. If requeue
- is false or the requeue attempt fails the messages are
- discarded or dead-lettered.
- :type requeue: bool (bit in AMQP)
"""
self.delivery_tag = delivery_tag
self.requeue = requeue
@@ -4319,14 +4008,14 @@ class BasicReject(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 9
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicReject
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicReject
offset = start_offset
delivery_tag, _bit, = struct.unpack_from('!QB', buf, offset)
offset += 8
requeue = bool(_bit >> 0)
offset += 1
- return BasicReject(delivery_tag, requeue)
+ return cls(delivery_tag, requeue)
class BasicRecoverAsync(AMQPMethodPayload):
@@ -4338,6 +4027,13 @@ class BasicRecoverAsync(AMQPMethodPayload):
specified channel. Zero or more messages may be redelivered.
This method
is deprecated in favour of the synchronous Recover/Recover-Ok.
+ :param requeue: Requeue the message
+ If this field is zero, the message will be redelivered to
+ the original
+ recipient. If this bit is 1, the server will attempt to
+ requeue the message,
+ potentially then delivering it to an alternative subscriber.
+ :type requeue: bool (bit in AMQP)
"""
__slots__ = (u'requeue', )
@@ -4352,13 +4048,14 @@ class BasicRecoverAsync(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'requeue', u'bit', u'bit', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'BasicRecoverAsync(%s)' % (', '.join(map(repr, [self.requeue])))
@@ -4366,14 +4063,6 @@ class BasicRecoverAsync(AMQPMethodPayload):
def __init__(self, requeue):
"""
Create frame basic.recover-async
-
- :param requeue: Requeue the message
- If this field is zero, the message will be redelivered to
- the original
- recipient. If this bit is 1, the server will attempt to
- requeue the message,
- potentially then delivering it to an alternative subscriber.
- :type requeue: bool (bit in AMQP)
"""
self.requeue = requeue
@@ -4383,15 +4072,14 @@ class BasicRecoverAsync(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> BasicRecoverAsync
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicRecoverAsync
offset = start_offset
_bit, = struct.unpack_from('!B', buf, offset)
offset += 0
requeue = bool(_bit >> 0)
offset += 1
- return BasicRecoverAsync(requeue)
+ return cls(requeue)
class BasicRecover(AMQPMethodPayload):
@@ -4403,6 +4091,13 @@ class BasicRecover(AMQPMethodPayload):
specified channel. Zero or more messages may be redelivered.
This method
replaces the asynchronous Recover.
+ :param requeue: Requeue the message
+ If this field is zero, the message will be redelivered to
+ the original
+ recipient. If this bit is 1, the server will attempt to
+ requeue the message,
+ potentially then delivering it to an alternative subscriber.
+ :type requeue: bool (bit in AMQP)
"""
__slots__ = (u'requeue', )
@@ -4417,13 +4112,14 @@ class BasicRecover(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'requeue', u'bit', u'bit', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'BasicRecover(%s)' % (', '.join(map(repr, [self.requeue])))
@@ -4431,14 +4127,6 @@ class BasicRecover(AMQPMethodPayload):
def __init__(self, requeue):
"""
Create frame basic.recover
-
- :param requeue: Requeue the message
- If this field is zero, the message will be redelivered to
- the original
- recipient. If this bit is 1, the server will attempt to
- requeue the message,
- potentially then delivering it to an alternative subscriber.
- :type requeue: bool (bit in AMQP)
"""
self.requeue = requeue
@@ -4448,14 +4136,14 @@ class BasicRecover(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> BasicRecover
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicRecover
offset = start_offset
_bit, = struct.unpack_from('!B', buf, offset)
offset += 0
requeue = bool(_bit >> 0)
offset += 1
- return BasicRecover(requeue)
+ return cls(requeue)
class BasicRecoverOk(AMQPMethodPayload):
@@ -4480,20 +4168,15 @@ class BasicRecoverOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'BasicRecoverOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame basic.recover-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> BasicRecoverOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> BasicRecoverOk
offset = start_offset
- return BasicRecoverOk()
+ return cls()
class Tx(AMQPClass):
@@ -4545,19 +4228,15 @@ class TxCommit(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'TxCommit(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame tx.commit
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> TxCommit
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> TxCommit
offset = start_offset
- return TxCommit()
+ return cls()
class TxCommitOk(AMQPMethodPayload):
@@ -4584,19 +4263,15 @@ class TxCommitOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'TxCommitOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame tx.commit-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> TxCommitOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> TxCommitOk
offset = start_offset
- return TxCommitOk()
+ return cls()
class TxRollback(AMQPMethodPayload):
@@ -4627,19 +4302,15 @@ class TxRollback(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'TxRollback(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame tx.rollback
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> TxRollback
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> TxRollback
offset = start_offset
- return TxRollback()
+ return cls()
class TxRollbackOk(AMQPMethodPayload):
@@ -4666,19 +4337,15 @@ class TxRollbackOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'TxRollbackOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame tx.rollback-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> TxRollbackOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> TxRollbackOk
offset = start_offset
- return TxRollbackOk()
+ return cls()
class TxSelect(AMQPMethodPayload):
@@ -4706,19 +4373,15 @@ class TxSelect(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'TxSelect(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame tx.select
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> TxSelect
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> TxSelect
offset = start_offset
- return TxSelect()
+ return cls()
class TxSelectOk(AMQPMethodPayload):
@@ -4745,19 +4408,15 @@ class TxSelectOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'TxSelectOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame tx.select-ok
- """
-
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> TxSelectOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> TxSelectOk
offset = start_offset
- return TxSelectOk()
+ return cls()
class Confirm(AMQPClass):
@@ -4791,6 +4450,12 @@ class ConfirmSelect(AMQPMethodPayload):
The client can only use this method on a non-transactional
channel.
+ :param nowait: If set, the server will not respond to the method. the
+ client should
+ not wait for a reply method. If the server could not
+ complete the
+ method it will raise a channel or connection exception.
+ :type nowait: bool (bit in AMQP)
"""
__slots__ = (u'nowait', )
@@ -4805,13 +4470,14 @@ class ConfirmSelect(AMQPMethodPayload):
IS_CONTENT_STATIC = False # this means that argument part has always the same content
# See constructor pydoc for details
- FIELDS = [
+ FIELDS = [
Field(u'nowait', u'bit', u'bit', reserved=False),
]
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConfirmSelect(%s)' % (', '.join(map(repr, [self.nowait])))
@@ -4819,13 +4485,6 @@ class ConfirmSelect(AMQPMethodPayload):
def __init__(self, nowait):
"""
Create frame confirm.select
-
- :param nowait: If set, the server will not respond to the method. the
- client should
- not wait for a reply method. If the server could not
- complete the
- method it will raise a channel or connection exception.
- :type nowait: bool (bit in AMQP)
"""
self.nowait = nowait
@@ -4835,14 +4494,14 @@ class ConfirmSelect(AMQPMethodPayload):
def get_size(self): # type: () -> int
return 1
- @staticmethod
- def from_buffer(buf, start_offset): # type: (buffer, int) -> ConfirmSelect
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConfirmSelect
offset = start_offset
_bit, = struct.unpack_from('!B', buf, offset)
offset += 0
nowait = bool(_bit >> 0)
offset += 1
- return ConfirmSelect(nowait)
+ return cls(nowait)
class ConfirmSelectOk(AMQPMethodPayload):
@@ -4868,152 +4527,149 @@ class ConfirmSelectOk(AMQPMethodPayload):
def __repr__(self): # type: () -> str
"""
Convert the frame to a Python-representable string
+
:return: Python string representation
"""
return 'ConfirmSelectOk(%s)' % (', '.join(map(repr, [])))
- def __init__(self):
- """
- Create frame confirm.select-ok
- """
-
- @staticmethod
- def from_buffer(buf,
- start_offset): # type: (buffer, int) -> ConfirmSelectOk
+ @classmethod
+ def from_buffer(cls, buf, start_offset): # type: (buffer, int) -> ConfirmSelectOk
offset = start_offset
- return ConfirmSelectOk()
+ return cls()
IDENT_TO_METHOD = {
- (90, 21): TxCommitOk,
- (60, 100): BasicRecoverAsync,
- (10, 11): ConnectionStartOk,
- (60, 40): BasicPublish,
- (60, 50): BasicReturn,
+ (10, 60): ConnectionBlocked,
+ (10, 50): ConnectionClose,
(10, 51): ConnectionCloseOk,
- (20, 20): ChannelFlow,
- (40, 31): ExchangeBindOk,
- (60, 21): BasicConsumeOk,
+ (10, 40): ConnectionOpen,
+ (10, 41): ConnectionOpenOk,
+ (10, 10): ConnectionStart,
+ (10, 20): ConnectionSecure,
+ (10, 11): ConnectionStartOk,
(10, 21): ConnectionSecureOk,
- (90, 30): TxRollback,
- (90, 10): TxSelect,
- (85, 11): ConfirmSelectOk,
- (10, 61): ConnectionUnblocked,
- (50, 11): QueueDeclareOk,
- (60, 70): BasicGet,
- (90, 11): TxSelectOk,
(10, 30): ConnectionTune,
- (60, 11): BasicQosOk,
- (60, 80): BasicAck,
- (20, 21): ChannelFlowOk,
- (60, 60): BasicDeliver,
- (90, 31): TxRollbackOk,
- (40, 40): ExchangeUnbind,
- (85, 10): ConfirmSelect,
- (50, 50): QueueUnbind,
- (60, 71): BasicGetOk,
- (50, 30): QueuePurge,
(10, 31): ConnectionTuneOk,
- (10, 40): ConnectionOpen,
- (60, 30): BasicCancel,
+ (10, 61): ConnectionUnblocked,
(20, 40): ChannelClose,
- (40, 10): ExchangeDeclare,
- (10, 50): ConnectionClose,
- (20, 10): ChannelOpen,
(20, 41): ChannelCloseOk,
- (60, 110): BasicRecover,
- (60, 90): BasicReject,
- (50, 31): QueuePurgeOk,
- (50, 40): QueueDelete,
+ (20, 20): ChannelFlow,
+ (20, 21): ChannelFlowOk,
+ (20, 10): ChannelOpen,
+ (20, 11): ChannelOpenOk,
+ (40, 30): ExchangeBind,
+ (40, 31): ExchangeBindOk,
+ (40, 10): ExchangeDeclare,
(40, 20): ExchangeDelete,
- (50, 20): QueueBind,
- (10, 41): ConnectionOpenOk,
- (60, 120): BasicNack,
- (60, 31): BasicCancelOk,
- (90, 20): TxCommit,
- (10, 10): ConnectionStart,
- (60, 10): BasicQos,
(40, 11): ExchangeDeclareOk,
(40, 21): ExchangeDeleteOk,
+ (40, 40): ExchangeUnbind,
(40, 51): ExchangeUnbindOk,
- (20, 11): ChannelOpenOk,
- (60, 72): BasicGetEmpty,
- (40, 30): ExchangeBind,
- (60, 111): BasicRecoverOk,
- (60, 20): BasicConsume,
- (10, 20): ConnectionSecure,
- (50, 41): QueueDeleteOk,
- (50, 51): QueueUnbindOk,
+ (50, 20): QueueBind,
(50, 21): QueueBindOk,
- (10, 60): ConnectionBlocked,
(50, 10): QueueDeclare,
+ (50, 40): QueueDelete,
+ (50, 11): QueueDeclareOk,
+ (50, 41): QueueDeleteOk,
+ (50, 30): QueuePurge,
+ (50, 31): QueuePurgeOk,
+ (50, 50): QueueUnbind,
+ (50, 51): QueueUnbindOk,
+ (60, 80): BasicAck,
+ (60, 20): BasicConsume,
+ (60, 30): BasicCancel,
+ (60, 21): BasicConsumeOk,
+ (60, 31): BasicCancelOk,
+ (60, 60): BasicDeliver,
+ (60, 70): BasicGet,
+ (60, 71): BasicGetOk,
+ (60, 72): BasicGetEmpty,
+ (60, 120): BasicNack,
+ (60, 40): BasicPublish,
+ (60, 10): BasicQos,
+ (60, 11): BasicQosOk,
+ (60, 50): BasicReturn,
+ (60, 90): BasicReject,
+ (60, 100): BasicRecoverAsync,
+ (60, 110): BasicRecover,
+ (60, 111): BasicRecoverOk,
+ (90, 20): TxCommit,
+ (90, 21): TxCommitOk,
+ (90, 30): TxRollback,
+ (90, 31): TxRollbackOk,
+ (90, 10): TxSelect,
+ (90, 11): TxSelectOk,
+ (85, 10): ConfirmSelect,
+ (85, 11): ConfirmSelectOk,
}
+
BINARY_HEADER_TO_METHOD = {
- b'\x00\x5A\x00\x15': TxCommitOk,
- b'\x00\x3C\x00\x64': BasicRecoverAsync,
- b'\x00\x0A\x00\x0B': ConnectionStartOk,
- b'\x00\x3C\x00\x28': BasicPublish,
- b'\x00\x3C\x00\x32': BasicReturn,
+ b'\x00\x0A\x00\x3C': ConnectionBlocked,
+ b'\x00\x0A\x00\x32': ConnectionClose,
b'\x00\x0A\x00\x33': ConnectionCloseOk,
- b'\x00\x14\x00\x14': ChannelFlow,
- b'\x00\x28\x00\x1F': ExchangeBindOk,
- b'\x00\x3C\x00\x15': BasicConsumeOk,
+ b'\x00\x0A\x00\x28': ConnectionOpen,
+ b'\x00\x0A\x00\x29': ConnectionOpenOk,
+ b'\x00\x0A\x00\x0A': ConnectionStart,
+ b'\x00\x0A\x00\x14': ConnectionSecure,
+ b'\x00\x0A\x00\x0B': ConnectionStartOk,
b'\x00\x0A\x00\x15': ConnectionSecureOk,
- b'\x00\x5A\x00\x1E': TxRollback,
- b'\x00\x5A\x00\x0A': TxSelect,
- b'\x00\x55\x00\x0B': ConfirmSelectOk,
- b'\x00\x0A\x00\x3D': ConnectionUnblocked,
- b'\x00\x32\x00\x0B': QueueDeclareOk,
- b'\x00\x3C\x00\x46': BasicGet,
- b'\x00\x5A\x00\x0B': TxSelectOk,
b'\x00\x0A\x00\x1E': ConnectionTune,
- b'\x00\x3C\x00\x0B': BasicQosOk,
- b'\x00\x3C\x00\x50': BasicAck,
- b'\x00\x14\x00\x15': ChannelFlowOk,
- b'\x00\x3C\x00\x3C': BasicDeliver,
- b'\x00\x5A\x00\x1F': TxRollbackOk,
- b'\x00\x28\x00\x28': ExchangeUnbind,
- b'\x00\x55\x00\x0A': ConfirmSelect,
- b'\x00\x32\x00\x32': QueueUnbind,
- b'\x00\x3C\x00\x47': BasicGetOk,
- b'\x00\x32\x00\x1E': QueuePurge,
b'\x00\x0A\x00\x1F': ConnectionTuneOk,
- b'\x00\x0A\x00\x28': ConnectionOpen,
- b'\x00\x3C\x00\x1E': BasicCancel,
+ b'\x00\x0A\x00\x3D': ConnectionUnblocked,
b'\x00\x14\x00\x28': ChannelClose,
- b'\x00\x28\x00\x0A': ExchangeDeclare,
- b'\x00\x0A\x00\x32': ConnectionClose,
- b'\x00\x14\x00\x0A': ChannelOpen,
b'\x00\x14\x00\x29': ChannelCloseOk,
- b'\x00\x3C\x00\x6E': BasicRecover,
- b'\x00\x3C\x00\x5A': BasicReject,
- b'\x00\x32\x00\x1F': QueuePurgeOk,
- b'\x00\x32\x00\x28': QueueDelete,
+ b'\x00\x14\x00\x14': ChannelFlow,
+ b'\x00\x14\x00\x15': ChannelFlowOk,
+ b'\x00\x14\x00\x0A': ChannelOpen,
+ b'\x00\x14\x00\x0B': ChannelOpenOk,
+ b'\x00\x28\x00\x1E': ExchangeBind,
+ b'\x00\x28\x00\x1F': ExchangeBindOk,
+ b'\x00\x28\x00\x0A': ExchangeDeclare,
b'\x00\x28\x00\x14': ExchangeDelete,
- b'\x00\x32\x00\x14': QueueBind,
- b'\x00\x0A\x00\x29': ConnectionOpenOk,
- b'\x00\x3C\x00\x78': BasicNack,
- b'\x00\x3C\x00\x1F': BasicCancelOk,
- b'\x00\x5A\x00\x14': TxCommit,
- b'\x00\x0A\x00\x0A': ConnectionStart,
- b'\x00\x3C\x00\x0A': BasicQos,
b'\x00\x28\x00\x0B': ExchangeDeclareOk,
b'\x00\x28\x00\x15': ExchangeDeleteOk,
+ b'\x00\x28\x00\x28': ExchangeUnbind,
b'\x00\x28\x00\x33': ExchangeUnbindOk,
- b'\x00\x14\x00\x0B': ChannelOpenOk,
- b'\x00\x3C\x00\x48': BasicGetEmpty,
- b'\x00\x28\x00\x1E': ExchangeBind,
- b'\x00\x3C\x00\x6F': BasicRecoverOk,
- b'\x00\x3C\x00\x14': BasicConsume,
- b'\x00\x0A\x00\x14': ConnectionSecure,
- b'\x00\x32\x00\x29': QueueDeleteOk,
- b'\x00\x32\x00\x33': QueueUnbindOk,
+ b'\x00\x32\x00\x14': QueueBind,
b'\x00\x32\x00\x15': QueueBindOk,
- b'\x00\x0A\x00\x3C': ConnectionBlocked,
b'\x00\x32\x00\x0A': QueueDeclare,
+ b'\x00\x32\x00\x28': QueueDelete,
+ b'\x00\x32\x00\x0B': QueueDeclareOk,
+ b'\x00\x32\x00\x29': QueueDeleteOk,
+ b'\x00\x32\x00\x1E': QueuePurge,
+ b'\x00\x32\x00\x1F': QueuePurgeOk,
+ b'\x00\x32\x00\x32': QueueUnbind,
+ b'\x00\x32\x00\x33': QueueUnbindOk,
+ b'\x00\x3C\x00\x50': BasicAck,
+ b'\x00\x3C\x00\x14': BasicConsume,
+ b'\x00\x3C\x00\x1E': BasicCancel,
+ b'\x00\x3C\x00\x15': BasicConsumeOk,
+ b'\x00\x3C\x00\x1F': BasicCancelOk,
+ b'\x00\x3C\x00\x3C': BasicDeliver,
+ b'\x00\x3C\x00\x46': BasicGet,
+ b'\x00\x3C\x00\x47': BasicGetOk,
+ b'\x00\x3C\x00\x48': BasicGetEmpty,
+ b'\x00\x3C\x00\x78': BasicNack,
+ b'\x00\x3C\x00\x28': BasicPublish,
+ b'\x00\x3C\x00\x0A': BasicQos,
+ b'\x00\x3C\x00\x0B': BasicQosOk,
+ b'\x00\x3C\x00\x32': BasicReturn,
+ b'\x00\x3C\x00\x5A': BasicReject,
+ b'\x00\x3C\x00\x64': BasicRecoverAsync,
+ b'\x00\x3C\x00\x6E': BasicRecover,
+ b'\x00\x3C\x00\x6F': BasicRecoverOk,
+ b'\x00\x5A\x00\x14': TxCommit,
+ b'\x00\x5A\x00\x15': TxCommitOk,
+ b'\x00\x5A\x00\x1E': TxRollback,
+ b'\x00\x5A\x00\x1F': TxRollbackOk,
+ b'\x00\x5A\x00\x0A': TxSelect,
+ b'\x00\x5A\x00\x0B': TxSelectOk,
+ b'\x00\x55\x00\x0A': ConfirmSelect,
+ b'\x00\x55\x00\x0B': ConfirmSelectOk,
}
+
CLASS_ID_TO_CONTENT_PROPERTY_LIST = {
60: BasicContentPropertyList,
}
@@ -5022,98 +4678,98 @@ CLASS_ID_TO_CONTENT_PROPERTY_LIST = {
# if a method is NOT a reply, it will not be in this dict
# a method may be a reply for AT MOST one method
REPLY_REASONS_FOR = {
- TxRollbackOk: TxRollback,
- ConnectionSecureOk: ConnectionSecure,
+ ConnectionCloseOk: ConnectionClose,
+ ConnectionOpenOk: ConnectionOpen,
ConnectionStartOk: ConnectionStart,
+ ConnectionSecureOk: ConnectionSecure,
ConnectionTuneOk: ConnectionTune,
- QueueDeclareOk: QueueDeclare,
- TxSelectOk: TxSelect,
- QueueBindOk: QueueBind,
- ExchangeDeleteOk: ExchangeDelete,
- ConnectionCloseOk: ConnectionClose,
- ChannelFlowOk: ChannelFlow,
- QueuePurgeOk: QueuePurge,
ChannelCloseOk: ChannelClose,
- BasicGetOk: BasicGet,
- ConnectionOpenOk: ConnectionOpen,
- TxCommitOk: TxCommit,
- BasicQosOk: BasicQos,
- ExchangeUnbindOk: ExchangeUnbind,
- ExchangeDeclareOk: ExchangeDeclare,
+ ChannelFlowOk: ChannelFlow,
ChannelOpenOk: ChannelOpen,
- QueueUnbindOk: QueueUnbind,
ExchangeBindOk: ExchangeBind,
+ ExchangeDeclareOk: ExchangeDeclare,
+ ExchangeDeleteOk: ExchangeDelete,
+ ExchangeUnbindOk: ExchangeUnbind,
+ QueueBindOk: QueueBind,
+ QueueDeclareOk: QueueDeclare,
+ QueueDeleteOk: QueueDelete,
+ QueuePurgeOk: QueuePurge,
+ QueueUnbindOk: QueueUnbind,
+ BasicConsumeOk: BasicConsume,
BasicCancelOk: BasicCancel,
+ BasicGetOk: BasicGet,
BasicGetEmpty: BasicGet,
+ BasicQosOk: BasicQos,
+ TxCommitOk: TxCommit,
+ TxRollbackOk: TxRollback,
+ TxSelectOk: TxSelect,
ConfirmSelectOk: ConfirmSelect,
- BasicConsumeOk: BasicConsume,
- QueueDeleteOk: QueueDelete,
}
# Methods that are replies for other, ie. ConnectionOpenOk: ConnectionOpen
# a method may be a reply for ONE or NONE other methods
# if a method has no replies, it will have an empty list as value here
REPLIES_FOR = {
- ConnectionTune: [ConnectionTuneOk],
+ ConnectionBlocked: [],
+ ConnectionClose: [ConnectionCloseOk],
+ ConnectionCloseOk: [],
+ ConnectionOpen: [ConnectionOpenOk],
+ ConnectionOpenOk: [],
+ ConnectionStart: [ConnectionStartOk],
+ ConnectionSecure: [ConnectionSecureOk],
+ ConnectionStartOk: [],
ConnectionSecureOk: [],
- TxCommitOk: [],
- ConfirmSelect: [ConfirmSelectOk],
- BasicPublish: [],
+ ConnectionTune: [ConnectionTuneOk],
ConnectionTuneOk: [],
- QueueBind: [QueueBindOk],
+ ConnectionUnblocked: [],
ChannelClose: [ChannelCloseOk],
- ConnectionBlocked: [],
- ExchangeDeleteOk: [],
- TxRollbackOk: [],
- BasicDeliver: [],
- QueuePurgeOk: [],
ChannelCloseOk: [],
- BasicAck: [],
- ConnectionOpenOk: [],
- ConnectionStart: [ConnectionStartOk],
- TxRollback: [TxRollbackOk],
- QueueUnbind: [QueueUnbindOk],
- BasicQosOk: [],
- ExchangeUnbindOk: [],
+ ChannelFlow: [ChannelFlowOk],
+ ChannelFlowOk: [],
+ ChannelOpen: [ChannelOpenOk],
+ ChannelOpenOk: [],
+ ExchangeBind: [ExchangeBindOk],
+ ExchangeBindOk: [],
+ ExchangeDeclare: [ExchangeDeclareOk],
+ ExchangeDelete: [ExchangeDeleteOk],
ExchangeDeclareOk: [],
- BasicRecover: [],
+ ExchangeDeleteOk: [],
+ ExchangeUnbind: [ExchangeUnbindOk],
+ ExchangeUnbindOk: [],
+ QueueBind: [QueueBindOk],
+ QueueBindOk: [],
QueueDeclare: [QueueDeclareOk],
- QueueUnbindOk: [],
- BasicReject: [],
QueueDelete: [QueueDeleteOk],
- BasicConsume: [BasicConsumeOk],
- BasicGetEmpty: [],
- ConnectionUnblocked: [],
- QueuePurge: [QueuePurgeOk],
+ QueueDeclareOk: [],
QueueDeleteOk: [],
- ChannelFlow: [ChannelFlowOk],
- ConnectionClose: [ConnectionCloseOk],
+ QueuePurge: [QueuePurgeOk],
+ QueuePurgeOk: [],
+ QueueUnbind: [QueueUnbindOk],
+ QueueUnbindOk: [],
+ BasicAck: [],
+ BasicConsume: [BasicConsumeOk],
+ BasicCancel: [BasicCancelOk],
BasicConsumeOk: [],
- ExchangeDelete: [ExchangeDeleteOk],
+ BasicCancelOk: [],
+ BasicDeliver: [],
+ BasicGet: [BasicGetOk, BasicGetEmpty],
+ BasicGetOk: [],
+ BasicGetEmpty: [],
+ BasicNack: [],
+ BasicPublish: [],
+ BasicQos: [BasicQosOk],
+ BasicQosOk: [],
+ BasicReturn: [],
+ BasicReject: [],
BasicRecoverAsync: [],
- ChannelOpen: [ChannelOpenOk],
+ BasicRecover: [],
BasicRecoverOk: [],
- ExchangeUnbind: [ExchangeUnbindOk],
- ConfirmSelectOk: [],
- QueueDeclareOk: [],
- BasicCancel: [BasicCancelOk],
- ExchangeBind: [ExchangeBindOk],
- ConnectionOpen: [ConnectionOpenOk],
TxCommit: [TxCommitOk],
+ TxCommitOk: [],
+ TxRollback: [TxRollbackOk],
+ TxRollbackOk: [],
TxSelect: [TxSelectOk],
- ChannelFlowOk: [],
- ConnectionStartOk: [],
- ChannelOpenOk: [],
TxSelectOk: [],
- BasicNack: [],
- QueueBindOk: [],
- BasicQos: [BasicQosOk],
- ConnectionSecure: [ConnectionSecureOk],
- BasicGet: [BasicGetOk, BasicGetEmpty],
- ExchangeDeclare: [ExchangeDeclareOk],
- ConnectionCloseOk: [],
- ExchangeBindOk: [],
- BasicCancelOk: [],
- BasicGetOk: [],
- BasicReturn: [],
+ ConfirmSelect: [ConfirmSelectOk],
+ ConfirmSelectOk: [],
}
diff --git a/docs/conf.py b/docs/conf.py
index 2f78e5356579968c4df70aaa7049a68debd310c1..e035c5a6a54362759036730f544a6fb387730517 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -153,5 +153,9 @@ texinfo_documents = [
'Miscellaneous'),
]
+from coolamqp.framing.definitions import BINARY_HEADER_TO_METHOD
-
+with open('frames.rst', 'w') as f_out:
+ for class_ in BINARY_HEADER_TO_METHOD.values():
+ f_out.write('.. autoclass:: coolamqp.framing.definitions.%s\n :members:\n\n' % (
+ class_.__qualname__))
diff --git a/docs/frames.rst b/docs/frames.rst
new file mode 100644
index 0000000000000000000000000000000000000000..ace0fdc35cc0928549f02087b0593abfe1817f4b
--- /dev/null
+++ b/docs/frames.rst
@@ -0,0 +1 @@
+To be automatically filled in during build by conf.py
diff --git a/docs/index.rst b/docs/index.rst
index f51540ec0059feb011f1cf2dca426ba124b09c12..e79a4a5c9f71a692a7bcff501fcc9642a3ffff99 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -7,7 +7,7 @@ Welcome to CoolAMQP's documentation!
tutorial
caveats
-
+ frames
Indices and tables
==================