-
Notifications
You must be signed in to change notification settings - Fork 0
Home
KevinGoodsell edited this page May 20, 2012
·
3 revisions
$ pydoc STAF
Help on package STAF:
NAME
STAF - Python bindings for STAF.
FILE
/home/kevin/projects/staf/STAF/__init__.py
DESCRIPTION
General Notes
-------------
* Most string results are unicode objects, because the underlying STAF APIs
being used are UTF-8 versions when available. unicode objects are also
accepted as parameters.
* Unmarshalled objects are common Python types -- lists, strings (actually
unicode objects), and dicts. Which type is returned depends on the request.
MapClass instances are specialized dicts which are returned for some requests.
Handles
-------
Handles are used for all interactions with STAF. They are represented with the
Handle class.
Handles implement the context manager interface. This allows handles to be
unregistered automatically:
with Handle('my-handle') as h:
h.submit('local', 'ping', 'ping')
# h is unregistered here.
The most important part of the Handle class is the submit() method, described in
detail below.
Handle.submit(where, service, request[, sync_option[, unmarshall]])
submit() submits a request to STAF.
'where' is the name of the destination machine.
'service' is the service name.
'request' may be either a string or a sequence of strings giving the
request. As a string, 'request' is sent as-is. As a sequence of strings, the
odd-numbered elements are automatically wrapped as option values. For
example:
h.submit('local', 'service', ['add service', serv_name, 'library',
lib_name, 'executable', exe_name])
This is equivalent to:
h.submit('local', 'service',
'add service ' + STAF.wrap_data(serv_name) +
' library ' + STAF.wrap_data(lib_name) +
' executable ' + STAF.wrap_data(exe_name))
When using the sequence form, you must put the command name and option names
at even-numbered indices. Only option values may be at odd-numbered indices.
STAF will produce an error if the command name or option names are wrapped,
and items at odd-numbered indices are always wrapped.
'sync_option' describes how the request and response should be handled. The
allowed values are:
STAF.REQ_SYNC
(default) The request is synchronous, returning only when it is
complete.
STAF.REQ_FIRE_AND_FORGET
The request is sent asynchronously. A request number is returned
immediately. No response is received.
STAF.REQ_QUEUE
The request is sent asynchronously. A request number is returned
immediately. The final result is placed in the submitter's queue,
retrievable via the QUEUE service.
STAF.REQ_RETAIN
The request is sent asynchronously. A request number is returned
immediately. The final result is stored, and can be retrieved and
freed with the SERVICE service's FREE command.
STAF.REQ_QUEUE_RETAIN
The request is sent asynchronously. A request number is returned
immediately. The final result is stored with the SERVICE service and
placed in the submitter's queue.
'unmarshall' determines what unmarshalling is done to the result. The
allowed values are:
STAF.UNMARSHALL_RECURSIVE
(default) The result is fully unmarshalled. Marshalled strings in
the results are unmarshalled recursively. This is similar to using
kSTAFUnmarshallingDefaults in the STAF C API.
STAF.UNMARSHALL_NON_RECURSIVE
The result is unmarshalled, but strings in the result are not
unmarshalled. This is similar to using kSTAFIgnoreIndirectObjects in
the STAF C API.
STAF.UNMARSHALL_NONE
No unmarshalling is done. The result is returned as a string.
Errors and Exceptions
---------------------
class STAFError(Exception)
Base class for all exceptions in the STAF package.
class STAFResultError(STAFError)
Exception raised for errors returned by STAF. Includes the following
attributes:
rc The integer return code returned by STAF. Will be None if the
exception was created with no arguments.
strerror
The string representation of the error. This is normally the string
that would be reported by the STAF HELP service for rc, though an
alternative string can be provided when the exception is created.
This will be None if rc is None.
extra
This will be a string with additional information about the error,
or None. Typically this is the result from a failed submit() call,
if there was a result.
class STAFUnmarshallError(STAFError)
Exception raised when unmarshalling fails. Note that typically you won't see
this, since by default unmarshalling is attempted and the original string is
returned if unmarshalling fails. The exception is unmarshall_force, which
will raise this if unmarshalling isn't possible.
class errors(object)
This is a class that simply collects the STAF error codes:
errors.Ok = 0
errors.InvalidAPI = 1
errors.UnknownService = 2
errors.InvalidHanle = 3
...
def strerror(rc)
Returns a string describing the given error code.
Unmarshalling
-------------
Two functions are available for doing unmarshalling:
def unmarshall(data[, mode])
def unmarshall_force(data[, mode])
Note: Unmarshalling usually happens automatically in the Handle.submit() call,
so the unmarshall() and unmarshall_force() functions aren't needed most of the
time. Unmarshalling can be skipped in the Handle.submit() call by passing
mode=STAF.UNMARSHALL_NONE.
unmarshall() and unmarshall_force() differ in how they deal with errors.
unmarshall() assumes that the string it is given may or may not actually be
marshalled data, so any unmarshalling error is taken to mean that the string is
just a plain string, and it is returned as-is. unmarshall_force() assumes that
the string is marshalled data and raises STAFUnmarshallError if it cannot be
unmarshalled.
The optional 'mode' argument has the same meaning as the 'unmarshall' argument
for Handle.submit(). Using STAF.UNMARSHALL_NONE makes both of these functions
no-ops, but is still supported for consistency with Handle.submit().
STAF has six data types that can appear in marshalled strings. These data types
and the corresponding Python type used to represent the unmarshalled forms are
as follows:
STAF Type | Python Type
--------------------------------------
None | None
String | str or unicode
List | list
Map | dict
Map Class | STAF.MapClass
Marshalling Context | (not used)
The first four are straight-forward. String results have the same type as the
original marshalled data string.
A Map Class is basically a Map with an associated Map Class Definition. The Map
Class Definition includes extra information that is typically only relevant for
displaying the Map Class data. This includes an ordering for the Map keys, a
display name for each key, and optionally a short form of the display name. The
Map Class Definition is represented in Python with the type
STAF.MapClassDefinition, described below.
Because Map Classes are just a special case of Maps, the STAF.MapClass type is
derived from dict and can be used much like any other dict. There are some
restrictions, however. See the full description of STAF.MapClass below.
A Marshalling Context is just a collection of Map Class Definitions and a "root
object" that may use those definitions. The root object is the interesting part,
and when a Marshalling Context is unmarshalled, this is the only part that is
returned. Thus, when unmarshalling is performed on a marshalled Marshalling
Context, the result will be one of the other types. Any Map Class Definitions
are implied by the structure of the corresponding STAF.MapClass, and an instance
of MapClassDefinition can be created with the definition() method.
class MapClass(dict)
Class used to represent unmarshalled Map Class objects. Functions like a
normal dict, but has a few additional attributes and restrictions, and some
slightly modified behaviors.
The main restriction is that you may not add keys to or remove keys from a
MapClass, because the structure of a MapClass is imposed by the Map Class
Definition.
MapClasses impose an ordering on the items they contain. This ordering is
determined by the MapClassDefinition used to create the MapClass. What this
means is that the various methods of iterating over or listing keys, values,
or both will always produce items in the order given by the Map Class
Definition. This ordering can be useful for printing formatted tables of
MapClass items.
The following extra attributes and methods are available:
mapclass.class_name
This instance attribute gives the name of the Map Class, which comes
frome the Map Class Definition.
mapclass.definition()
This method creates a new instance of MapClassDefinition that describes
the structure of this MapClass.
mapclass.display_name(key)
mapclass.display_short_name(key)
Returns the display name or short display name for the given key.
display_short_name() will return None if no short display name was
defined for the key.
class MapClassDefinition(object)
Defines the structure of a MapClass instance. This includes which keys will
be present in the MapClass, the ordering for those keys, the display name
for each key, and an optional short form of the display name for each key.
Short display names may exist for some keys in the MapClassDefinition and
not others.
MapClassDefinitions are used to create MapClasses. There's nothing wrong
with using MapClassDefinitions directly, but it shouldn't be necessary most
of the time.
The following attributes are available:
mapclassdef.name
This instance attribute is a string giving the name of the Map Class
Definition. This is primarily used internally for identifying the Map
Class Definition used by a particular Map Class.
mapclassdef.keys
This instance attribute is a list of key names defined for Map Classes
using this Map Class Definition. The ordering of the keys in this list
gives the ordering of Map Class items. This attribute should not be
modified directly. Use the add_item() method to add new keys.
mapclassdef.add_item(key, display_name[, display_short_name])
Add a new key along with its display name and optionally a short display
name. This adds the key to the end of the 'keys' list.
mapclassdef.display_name(key)
mapclassdef.display_short_name(key)
Returns the display name or short display name for the given key.
display_short_name() will return None if no short display name was
defined for the key.
Misc. Functions
---------------
See the docstrings for the full documentation for these functions.
wrap_data(data)
add_privacy_delimiters(data)
remove_privacy_delimiters(data[, num_levels])
mask_private_data(data)
escape_privacy_delimiters(data)
PACKAGE CONTENTS
_api
_errors
_mapclass
_marshall
_staf
CLASSES
__builtin__.dict(__builtin__.object)
MapClass
__builtin__.object
Handle
MapClassDefinition
errors
exceptions.Exception(exceptions.BaseException)
STAFError
STAFResultError
STAFUnmarshallError
class Handle(__builtin__.object)
| Represents a STAF handle, used for most STAF interactions. Use as a context
| manager to automatically unregister the handle.
|
| Methods defined here:
|
| __enter__(self)
|
| __exit__(self, exc_type, exc_value, exc_tb)
|
| __init__(self, name)
| Create a Handle. If 'name' is a string, it is used as the name for
| registering the handle. If 'name' is an integer then it must be the
| number of a previously registered static handle. Note that static
| handles don't get unregistered, even if you call unregister().
|
| __repr__(self)
|
| handle_num(self)
| Returns the handle number.
|
| is_registered(self)
| Returns true if the handle is registered, false if it has been
| unregistered.
|
| is_static(self)
| Returns true if the handle is static, false otherwise.
|
| submit(self, where, service, request, sync_option=0, unmarshall=STAF.UNMARSHALL_RECURSIVE)
| Send a command to a STAF service. Arguments work mostly like the
| Submit2UTF8 C API. See the STAF package documentation for full details.
|
| unregister(self)
| Unregister the handle. For static handles this is a no-op. The error
| HandleDoesNotExist is ignored, since this indicates that the handle
| isn't registered, which is the requested state.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class MapClass(__builtin__.dict)
| Represents a map class instance. This is a dict and can be accessed the same
| way. It also has 'display_name' and 'display_short_name' methods for getting
| the display names for a key.
|
| Adding and removing keys are not supported.
|
| Method resolution order:
| MapClass
| __builtin__.dict
| __builtin__.object
|
| Methods defined here:
|
| __delitem__(self, key)
| Not supported, raises NotImplementedError.
|
| __init__(self, class_name, keys, disp_names)
| Create a new MapClass. 'class_name' gives the Map Class name, 'keys'
| is a sequence giving the keys in the Map and their ordering, and
| disp_names is a dict mapping key names to (display_name,
| display_short_name) tuples, where display_short_name may be None.
|
| This should generally not be used directly. Instead, create a
| MapClassDefinition, populate it with keys, then use its map_class method
| to create MapClass instances.
|
| __iter__(self)
| x.__iter__() <==> iter(x)
|
| __repr__(self)
| x.__repr__() <==> repr(x)
|
| __setitem__(self, key, value)
| Implements self[key] = value, but raises KeyError if key is not in the
| Map Class Definition.
|
| clear(self)
| Not supported, raises NotImplementedError.
|
| definition(self)
| Return a new MapClassDefinition using the structure of this MapClass.
|
| display_name(self, key)
| Returns the display name for 'key'.
|
| display_short_name(self, key)
| Returns the short form of the display name for 'key', or None if no
| short name is defined.
|
| items(self)
| D.items() -> list of D's (key, value) pairs, as 2-tuples
|
| iteritems(self)
| D.iteritems() -> an iterator over the (key, value) items of D
|
| iterkeys(self)
| D.iterkeys() -> an iterator over the keys of D
|
| itervalues(self)
| D.itervalues() -> an iterator over the values of D
|
| keys(self)
| D.keys() -> list of D's keys
|
| pop(self, key, default=None)
| Not supported, raises NotImplementedError.
|
| popitem(self)
| Not supported, raises NotImplementedError.
|
| setdefault(self, key, default=None)
| Modified dict.setdefault, raises KeyError if the key is not in the Map
| Class Definition.
|
| update(self, *args, **kwargs)
| Modified dict.update, raises KeyError if the any key is not in the Map
| Class Definition.
|
| values(self)
| D.values() -> list of D's values
|
| viewitems(self)
| D.viewitems() -> a set-like object providing a view on D's items
|
| viewkeys(self)
| D.viewkeys() -> a set-like object providing a view on D's keys
|
| viewvalues(self)
| D.viewvalues() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| 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
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __len__(...)
| x.__len__() <==> len(x)
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| fromkeys(...)
| dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
| v defaults to None.
|
| get(...)
| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
|
| has_key(...)
| D.has_key(k) -> True if D has a key k, else False
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from __builtin__.dict:
|
| __hash__ = None
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
class MapClassDefinition(__builtin__.object)
| Represents a map class definition, which provides the set of key names and
| long and short display names for the keys.
|
| Methods defined here:
|
| __init__(self, name)
|
| __repr__(self)
|
| add_item(self, key, display_name, display_short_name=None)
| Add a key and a display name for it. Optionally include a short display
| name.
|
| display_name(self, key)
| Returns the display name for 'key'.
|
| display_short_name(self, key)
| Returns the short form of the display name for 'key', or None if no
| short name is defined.
|
| map_class(self, *args, **kwargs)
| Return a MapClass instance based on this definition.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class STAFError(exceptions.Exception)
| Base class for all STAF errors.
|
| Method resolution order:
| STAFError
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.Exception:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.Exception:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
class STAFResultError(STAFError)
| Error for STAF API return codes, modelled after EnvironmetError. This should
| usually be created with STAFResultError(rc[, strerror[, extra]]). 'strerror'
| will be filled in from strerror() if it's not included. 'extra' is an
| optional string with additional information. Typically 'extra' is set to the
| result of a submit() call that returns an error.
|
| These arguments are available as the attributes 'rc', 'strerror', and
| 'extra'. 'extra' will be None if not specified. All will be None if the
| object is created with no arguments, or with more than three.
|
| Method resolution order:
| STAFResultError
| STAFError
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Methods defined here:
|
| __init__(self, *args)
|
| __str__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from STAFError:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.Exception:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
class STAFUnmarshallError(STAFError)
| Method resolution order:
| STAFUnmarshallError
| STAFError
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors inherited from STAFError:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.Exception:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.Exception:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.BaseException:
|
| __delattr__(...)
| x.__delattr__('name') <==> del x.name
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __setattr__(...)
| x.__setattr__('name', value) <==> x.name = value
|
| __setstate__(...)
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __unicode__(...)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from exceptions.BaseException:
|
| __dict__
|
| args
|
| message
class errors(__builtin__.object)
| Constants for STAF errors.
|
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| AccessDenied = 25
|
| AlreadyExists = 49
|
| BaseOSError = 10
|
| CommunicationError = 22
|
| ConverterError = 39
|
| CreateThreadError = 57
|
| DiagnosticsNotEnabled = 52
|
| DirectoryCopyError = 51
|
| DirectoryNotEmpty = 50
|
| DoesNotExist = 48
|
| FileDeleteError = 20
|
| FileOpenError = 17
|
| FileReadError = 18
|
| FileWriteError = 19
|
| HandleAlreadyAuthenticated = 54
|
| HandleAlreadyExists = 4
|
| HandleAuthenticationDenied = 53
|
| HandleDoesNotExist = 5
|
| InvalidAPI = 1
|
| InvalidAPILevel = 31
|
| InvalidAsynchOption = 44
|
| InvalidHandle = 3
|
| InvalidObject = 41
|
| InvalidParm = 42
|
| InvalidRequestString = 7
|
| InvalidResolveString = 15
|
| InvalidSTAFVersion = 55
|
| InvalidServiceResult = 8
|
| InvalidTrustLevel = 24
|
| InvalidValue = 47
|
| JavaError = 38
|
| MaximumHandlesExceeded = 59
|
| MaximumSizeExceeded = 58
|
| MoveError = 40
|
| NoPathToMachine = 16
|
| NoQueueElement = 29
|
| NotRequester = 60
|
| NotRunning = 21
|
| NotSemaphoreOwner = 35
|
| NotifieeDoesNotExist = 30
|
| Ok = 0
|
| ProcessAlreadyComplete = 11
|
| ProcessAuthenticationDenied = 46
|
| ProcessNotComplete = 12
|
| QueueFull = 28
|
| REXXError = 9
|
| RegistrationError = 26
|
| RequestCancelled = 56
|
| RequestNotComplete = 45
|
| RequestNumberNotFound = 43
|
| SemaphoreDoesNotExist = 34
|
| SemaphoreHasPendingRequests = 36
|
| ServiceConfigurationError = 27
|
| ServiceNotAvailable = 33
|
| ServiceNotUnregisterable = 32
|
| Timeout = 37
|
| TrusteeDoesNotExist = 23
|
| UnResolvableString = 14
|
| UnknownError = 6
|
| UnknownService = 2
|
| UserDefined = 4000
|
| VariableDoesNotExist = 13
FUNCTIONS
add_privacy_delimiters(data)
Encloses the given string in privacy delimiters, identifying it as a section
that should be masked when displayed. E.g., for passwords.
escape_privacy_delimiters(data)
Escapes any privacy delimiters in the given string. This prevents them from
being interpreted as privacy delimiters when displayed by commands that hide
private data.
mask_private_data(data)
Replaces private data in the given string with asterisks.
remove_privacy_delimiters(data, num_levels=0)
Removes privacy delimiters from the given string. By default this is done
repeatedly until no privacy delimiters remain. Alternatively, num_levels
gives the number of levels of delimiters to remove.
strerror(rc)
Return the string description for a STAF error code, or None if the error
code is unknown.
unmarshall(data, mode=STAF.UNMARSHALL_RECURSIVE)
Try to unmarshall the string in 'data'. 'mode' determines how unmarshalling
is done.
'mode' can be one of the following:
UNMARSHALL_RECURSIVE (default) - Tries to recursively unmarshall any
string result.
UNMARSHALL_NON_RECURSIVE - leaves string results as they are, doesn't
attept further unmarshalling.
UNMARSHALL_NONE - doesn't do any unmarshalling.
Returns 'data' if it doesn't appear to be a marshalled object, or if 'mode'
is UNMARSHALL_NONE.
unmarshall_force(data, mode=STAF.UNMARSHALL_RECURSIVE)
Same as unmarshall, but raises STAFUnmarshallError if unmarshalling isn't
possible.
wrap_data(data)
Make a colon-length-colon-prefixed string suitable for use as a single
service option value in a submit() call.
DATA
REQ_FIRE_AND_FORGET = 1
REQ_QUEUE = 2
REQ_QUEUE_RETAIN = 4
REQ_RETAIN = 3
REQ_SYNC = 0
UNMARSHALL_NONE = STAF.UNMARSHALL_NONE
UNMARSHALL_NON_RECURSIVE = STAF.UNMARSHALL_NON_RECURSIVE
UNMARSHALL_RECURSIVE = STAF.UNMARSHALL_RECURSIVE
__all__ = ['REQ_SYNC', 'REQ_FIRE_AND_FORGET', 'REQ_QUEUE', 'REQ_RETAIN...