mpdlib

Langue: en

Version: 22 February 2010 (ubuntu - 24/10/10)

Section: 1 (Commandes utilisateur)

Sommaire

NAME

mpdlib  

FILE

/Users/goodell/svn/mpich2-1.2.1p1-tmp/src/pm/mpd/mpdlib.py

DESCRIPTION

#
(C) 2001 by Argonne National Laboratory.
#
See COPYRIGHT in top-level directory. #

CLASSES

__builtin__.dict(__builtin__.object) MPDParmDB __builtin__.object MPDRing MPDSock MPDConClientSock MPDListenSock MPDConListenSock MPDStreamHandler MPDTest

class MPDConClientSock(MPDSock)

|
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)

class MPDConListenSock(MPDListenSock)

|
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)

class MPDListenSock(MPDSock)

|
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)

class MPDParmDB(__builtin__.dict)

|
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.

class MPDRing(__builtin__.object)

|
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)

class MPDSock(__builtin__.object)

|
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)

class MPDStreamHandler(__builtin__.object)

|
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)

class MPDTest(__builtin__.object)

|
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)

FUNCTIONS

dumps(...) dumps(obj, protocol=0) -- Return a string containing an object in pickle format.

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

loads(...) loads(string) -- Load a pickle from the given string

md5new = openssl_md5(...) Returns a md5 hash object; optionally initialized with a string

mpd_check_python_version()

mpd_close_zc()

mpd_find_zc_peer(peer_level)

mpd_get_groups_for_username(username)

mpd_get_my_id()

mpd_get_my_username()

mpd_get_ranks_in_binary_tree(myRank, nprocs)

mpd_handle_signal(signum, frame)

mpd_init_zc(ifhn, my_level) #### experimental code for zeroconf

mpd_print(*args)

mpd_print_tb(*args)

mpd_read_nbytes(fd, nbytes)

mpd_register_zc(ifhn, level)

mpd_same_ips(host1, host2)

mpd_set_cli_app(app)

mpd_set_dbg_level(flag)

mpd_set_my_id(myid='')

mpd_set_procedures_to_trace(procs)

mpd_set_tmpdir(tmpdir)

mpd_sockpair()

mpd_trace_calls(frame, event, args)

mpd_trace_returns(frame, event, args)

mpd_uncaught_except_tb(arg1, arg2, arg3)

mpd_version()

mpd_which(execName, user_path=None)

random(...) random() -> x in the interval [0, 1).

sleep(...) sleep(seconds)

Delay execution for a given number of seconds.
The argument may be a floating point number for subsecond precision.

DATA

ECONNREFUSED = 61 ECONNRESET = 54 EINTR = 4 EISCONN = 56 EPIPE = 32 grp_module_available = 1 mpd_cli_app = '' mpd_dbg_level = 0 mpd_my_hostname = '' mpd_my_id = '' mpd_procedures_to_trace = [] mpd_signum = 0 mpd_tmpdir = '/tmp' mpd_zc = 0 pwd_module_available = 1 subprocess_module_available = 1 syslog_module_available = 1