mpdlib(1)

|

Method resolution order:

|

MPDConClientSock

|

MPDSock

|

__builtin__.object

|

|

Methods defined here:

|

|

__init__(self, name='console_to_mpd', mpdroot='', secretword='', **kargs)

|

|

----------------------------------------------------------------------

|

Methods inherited from MPDSock:

|

|

accept(self, name='accepter')

|

|

close(self)

|

|

connect(self, *args)

|

|

fileno(self)

|

|

getsockname(self)

|

|

recv(self, nbytes)

|

|

recv_char_msg(self)

|

|

recv_dict_msg(self, timeout=None)

|

|

recv_one_line(self)

|

|

send_char_msg(self, msg, errprint=1)

|

|

send_dict_msg(self, msg, errprint=1)

|

# The default behavior on an error needs to be to handle and/or report

|

# it. Otherwise, we all waste time trying to figure out why

|

# the code is silently failing. I've set the default for errprint

|

# to YES rather than NO.

|

|

sendall(self, data)

|

|

----------------------------------------------------------------------

|

Data descriptors inherited from MPDSock:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

Method resolution order:

|

MPDConListenSock

|

MPDListenSock

|

MPDSock

|

__builtin__.object

|

|

Methods defined here:

|

|

__init__(self, name='console_listen', secretword='', **kargs)

|

|

----------------------------------------------------------------------

|

Methods inherited from MPDSock:

|

|

accept(self, name='accepter')

|

|

close(self)

|

|

connect(self, *args)

|

|

fileno(self)

|

|

getsockname(self)

|

|

recv(self, nbytes)

|

|

recv_char_msg(self)

|

|

recv_dict_msg(self, timeout=None)

|

|

recv_one_line(self)

|

|

send_char_msg(self, msg, errprint=1)

|

|

send_dict_msg(self, msg, errprint=1)

|

# The default behavior on an error needs to be to handle and/or report

|

# it. Otherwise, we all waste time trying to figure out why

|

# the code is silently failing. I've set the default for errprint

|

# to YES rather than NO.

|

|

sendall(self, data)

|

|

----------------------------------------------------------------------

|

Data descriptors inherited from MPDSock:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

Method resolution order:

|

MPDListenSock

|

MPDSock

|

__builtin__.object

|

|

Methods defined here:

|

|

__init__(self, host='', port=0, filename='', listen=5, name='listener', **kargs)

|

|

----------------------------------------------------------------------

|

Methods inherited from MPDSock:

|

|

accept(self, name='accepter')

|

|

close(self)

|

|

connect(self, *args)

|

|

fileno(self)

|

|

getsockname(self)

|

|

recv(self, nbytes)

|

|

recv_char_msg(self)

|

|

recv_dict_msg(self, timeout=None)

|

|

recv_one_line(self)

|

|

send_char_msg(self, msg, errprint=1)

|

|

send_dict_msg(self, msg, errprint=1)

|

# The default behavior on an error needs to be to handle and/or report

|

# it. Otherwise, we all waste time trying to figure out why

|

# the code is silently failing. I've set the default for errprint

|

# to YES rather than NO.

|

|

sendall(self, data)

|

|

----------------------------------------------------------------------

|

Data descriptors inherited from MPDSock:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

Method resolution order:

|

MPDParmDB

|

__builtin__.dict

|

__builtin__.object

|

|

Methods defined here:

|

|

__getitem__(self, key)

|

|

__init__(self, orderedSources=[])

|

|

__setitem__(self, sk_tup, val)

|

|

get_parms_from_env(self, parmsToOverride)

|

|

get_parms_from_rcfile(self, parmsToOverride, errIfMissingFile=0)

|

|

has_key(self, key)

|

|

printall(self)

|

|

printdef(self)

|

|

----------------------------------------------------------------------

|

Data descriptors defined here:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

|

----------------------------------------------------------------------

|

Methods inherited from __builtin__.dict:

|

|

__cmp__(...)

|

x.__cmp__(y) <==> cmp(x,y)

|

|

__contains__(...)

|

D.__contains__(k) -> True if D has a key k, else False

|

|

__delitem__(...)

|

x.__delitem__(y) <==> del x[y]

|

|

__eq__(...)

|

x.__eq__(y) <==> x==y

|

|

__ge__(...)

|

x.__ge__(y) <==> x>=y

|

|

__getattribute__(...)

|

x.__getattribute__('name') <==> x.name

|

|

__gt__(...)

|

x.__gt__(y) <==> x>y

|

|

__hash__(...)

|

x.__hash__() <==> hash(x)

|

|

__iter__(...)

|

x.__iter__() <==> iter(x)

|

|

__le__(...)

|

x.__le__(y) <==> x<=y

|

|

__len__(...)

|

x.__len__() <==> len(x)

|

|

__lt__(...)

|

x.__lt__(y) <==> x<y

|

|

__ne__(...)

|

x.__ne__(y) <==> x!=y

|

|

__repr__(...)

|

x.__repr__() <==> repr(x)

|

|

clear(...)

|

D.clear() -> None. Remove all items from D.

|

|

copy(...)

|

D.copy() -> a shallow copy of D

|

|

get(...)

|

D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

|

|

items(...)

|

D.items() -> list of D's (key, value) pairs, as 2-tuples

|

|

iteritems(...)

|

D.iteritems() -> an iterator over the (key, value) items of D

|

|

iterkeys(...)

|

D.iterkeys() -> an iterator over the keys of D

|

|

itervalues(...)

|

D.itervalues() -> an iterator over the values of D

|

|

keys(...)

|

D.keys() -> list of D's keys

|

|

pop(...)

|

D.pop(k[,d]) -> v, remove specified key and return the corresponding value

|

If key is not found, d is returned if given, otherwise KeyError is raised

|

|

popitem(...)

|

D.popitem() -> (k, v), remove and return some (key, value) pair as a

|

2-tuple; but raise KeyError if D is empty

|

|

setdefault(...)

|

D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

|

|

update(...)

|

D.update(E, **F) -> None. Update D from E and F: for k in E: D[k] = E[k]

|

(if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]

|

|

values(...)

|

D.values() -> list of D's values

|

|

----------------------------------------------------------------------

|

Data and other attributes inherited from __builtin__.dict:

|

|

__new__ = <built-in method __new__ of type object at 0x1eeec0>

|

T.__new__(S, ...) -> a new object with type S, a subtype of T

|

|

fromkeys = <built-in method fromkeys of type object at 0x339390>

|

dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.

|

v defaults to None.

|

Methods defined here:

|

|

__init__(self, listenSock=None, streamHandler=None, secretword='', myIfhn='', entryIfhn='', entryPort=0, zcMyLevel=0)

|

|

accept_lhs(self, lhsHandler=None)

|

|

accept_rhs(self, rhsHandler=None)

|

|

connect_lhs(self, lhsIfhn='', lhsPort=0, lhsHandler=None, numTries=1)

|

|

connect_rhs(self, rhsIfhn='', rhsPort=0, rhsHandler=None, numTries=1)

|

|

create_single_mem_ring(self, ifhn='', port=0, lhsHandler=None, rhsHandler=None)

|

|

enter_ring(self, entryIfhn='', entryPort=0, lhsHandler='', rhsHandler='', ntries=1)

|

|

handle_lhs_challenge_response(self, sock)

|

|

handle_rhs_challenge_response(self, sock)

|

|

handle_ring_listener_connection(self, sock)

|

|

reenter_ring(self, entryIfhn='', entryPort=0, lhsHandler='', rhsHandler='', ntries=5)

|

|

----------------------------------------------------------------------

|

Data descriptors defined here:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

Methods defined here:

|

|

__init__(self, family=2, socktype=1, proto=0, sock=None, name='')

|

|

accept(self, name='accepter')

|

|

close(self)

|

|

connect(self, *args)

|

|

fileno(self)

|

|

getsockname(self)

|

|

recv(self, nbytes)

|

|

recv_char_msg(self)

|

|

recv_dict_msg(self, timeout=None)

|

|

recv_one_line(self)

|

|

send_char_msg(self, msg, errprint=1)

|

|

send_dict_msg(self, msg, errprint=1)

|

# The default behavior on an error needs to be to handle and/or report

|

# it. Otherwise, we all waste time trying to figure out why

|

# the code is silently failing. I've set the default for errprint

|

# to YES rather than NO.

|

|

sendall(self, data)

|

|

----------------------------------------------------------------------

|

Data descriptors defined here:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

Methods defined here:

|

|

__init__(self)

|

|

close_all_active_streams(self)

|

|

del_handler(self, stream)

|

|

handle_active_streams(self, streams=None, timeout=0.10000000000000001)

|

|

set_handler(self, stream, handler, args=())

|

|

----------------------------------------------------------------------

|

Data descriptors defined here:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

|

Methods defined here:

|

|

__init__(self)

|

|

run(self, cmd='', expIn='', chkEC=0, expEC=0, chkOut=0, expOut='', ordOut=0, grepOut=0, exitOnFail=1)

|

|

----------------------------------------------------------------------

|

Data descriptors defined here:

|

|

__dict__

|

dictionary for instance variables (if defined)

|

|

__weakref__

|

list of weak references to the object (if defined)

See the Pickler docstring for the meaning of optional argument proto.

Delay execution for a given number of seconds.

The argument may be a floating point number for subsecond precision.