API docs for “twisted.protocols.amp.Command”

Subclass me to specify an AMP Command.

Instance Variables	requiresAnswer	a boolean; defaults to True. Set it to False on your subclass if you want callRemote to return None. Note: this is a hint only to the client side of the protocol. The return-type of a command responder method must always be a dictionary adhering to the contract specified by `response`, because clients are always free to request a response if they want one.
Class Variables	arguments	A list of 2-tuples of (name, Argument-subclass-instance), specifying the names and values of the parameters which are required for this command.
	response	A list like `arguments`, but instead used for the return value.
	errors	A mapping of subclasses of `Exception` to wire-protocol tags for errors represented as `str`s. Responders which raise keys from this dictionary will have the error translated to the corresponding tag on the wire. Invokers which receive Deferreds from invoking this command with `AMP.callRemote` will potentially receive Failures with keys from this mapping as their value. This mapping is inherited; if you declare a command which handles `FooError` as 'FOO_ERROR', then subclass it and specify `BarError` as 'BAR_ERROR', responders to the subclass may raise either `FooError` or `BarError`, and invokers must be able to deal with either of those exceptions.
	fatalErrors	like 'errors', but errors in this list will always terminate the connection, despite being of a recognizable error type.
	commandType	The type of Box used to issue commands; useful only for protocol-modifying behavior like startTLS or protocol switching. Defaults to a plain vanilla `Box`.
	responseType	The type of Box used to respond to this command; only useful for protocol-modifying behavior like startTLS or protocol switching. Defaults to a plain vanilla `Box`.

def makeResponse(cls, objects, proto): (source)

overridden in twisted.protocols.amp.ProtocolSwitchCommand

This is a hook which can be used to implement a custom factory response.

Parameters	objects	a dict with keys similar to the names specified in self.arguments, having values of the types that the Argument objects in self.arguments can format.
	proto	an `AMP`.
Returns	an `AmpBox`.

def responder(cls, methodfunc): (source)

Declare a method to be a responder for a particular command.

This is a decorator.

Use like so:

   class MyCommand(Command):
       arguments = [('a', ...), ('b', ...)]

   class MyProto(AMP):
       def myFunMethod(self, a, b):
           ...
       MyCommand.responder(myFunMethod)

Notes: Although decorator syntax is not used within Twisted, this function returns its argument and is therefore safe to use with decorator syntax.

This is not thread safe. Don't declare AMP subclasses in other threads. Don't declare responders outside the scope of AMP subclasses; the behavior is undefined.

Parameters	methodfunc	A function which will later become a method, which has a keyword signature compatible with this command's `argument` list and returns a dictionary with a set of keys compatible with this command's `response` list.
Returns	the methodfunc parameter.

Parameters	kw	a dict containing an appropriate value for each name specified in the `arguments` attribute of my class.
Raises	InvalidSignature	if you forgot any required arguments.

Class	__metaclass__	Metaclass hack to establish reverse-mappings for 'errors' and
Method	__init__	Create an instance of this command with specified values for its
Method	makeResponse	This is a hook which can be used to implement a custom factory
Method	responder	Declare a method to be a responder for a particular command.
Method	_doCommand	Encode and send this Command to the given protocol.

Parameters	proto	an AMP, representing the connection to send to.
Returns	a Deferred which will fire or error appropriately when the other side responds to the command (or error if the connection is lost before it is responded to).

Class t.p.a.Command: