StreamBase client API for Python

Modules
		_streambase

Classes
		__builtin__.object BoolVector Client ClientSettings CompleteDataType DataType DequeueResult DoubleVector EntityType Errors Field FieldValue FieldValueVector FieldVector Function IntVector ListVector LongVector Schema SchemaRep StreamProperties StringHashFunc StringVector SwigPyIterator Timestamp TimestampVector Tuple TupleList TuplePrivateImpl TupleVector URI URIVector Version exceptions.Exception(exceptions.BaseException) StreamBaseException ArgumentOutOfRange StreamBaseXmlRpcFault   class ArgumentOutOfRange(StreamBaseException)     Null value encountered.     C++ includes: DequeueResult.hpp     Method resolution order: ArgumentOutOfRange StreamBaseException exceptions.Exception exceptions.BaseException __builtin__.object Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self, string code, string message, Type a_error_type = NON_FATAL_ERROR,      char type = "ArgumentOutOfRange") -> ArgumentOutOfRange __init__(self, string code, string message, Type a_error_type = NON_FATAL_ERROR) -> ArgumentOutOfRange __init__(self, string code, string message) -> ArgumentOutOfRange __init__(self, string code, string message, StreamBaseException c,      Type a_error_type = NON_FATAL_ERROR, char type = "ArgumentOutOfRange") -> ArgumentOutOfRange __init__(self, string code, string message, StreamBaseException c,      Type a_error_type = NON_FATAL_ERROR) -> ArgumentOutOfRange __init__(self, string code, string message, StreamBaseException c) -> ArgumentOutOfRange __repr__ = _swig_repr(self) __setattr__ lambda self, name, value throwMyself(self) throwMyself(self) Data and other attributes defined here: __swig_destroy__ = <built-in function delete_ArgumentOutOfRange> delete_ArgumentOutOfRange(ArgumentOutOfRange self) __swig_getmethods__ = {'fromXmlString': <function <lambda>>} __swig_setmethods__ = {} Methods inherited from StreamBaseException: __str__(self) x.__str__() <==> str(x) asXmlString(self) asXmlString(self) -> string asXmlStringSingle(self) asXmlStringSingle(self) -> string boxname(self, *args) boxname(self, string name) -> StreamBaseException boxparam(self, *args) boxparam(self, string name) -> StreamBaseException cause(self, *args) cause(self, StreamBaseException val) -> StreamBaseException chainAsString(self) chainAsString(self) -> string code(self, *args) code(self, string val) -> StreamBaseException code(self, int val) -> StreamBaseException fieldname(self, *args) fieldname(self, string name) -> StreamBaseException file(self, *args) file(self, char val) -> StreamBaseException file(self, string val) -> StreamBaseException findByType(self, *args) findByType(self, string type) -> StreamBaseException function(self, *args) function(self, char val) -> StreamBaseException function(self, string val) -> StreamBaseException getBoxName(self) getBoxName(self) -> string getBoxParam(self) getBoxParam(self) -> string getCause(self) getCause(self) -> StreamBaseException getChainOfMessages(self) getChainOfMessages(self) -> string getCode(self) getCode(self) -> string getDeepest(self) getDeepest(self) -> StreamBaseException getErrorType(self) getErrorType(self) -> Type getFieldName(self) getFieldName(self) -> string getFile(self) getFile(self) -> string getFunction(self) getFunction(self) -> string getLine(self) getLine(self) -> unsigned int getMessage(self) getMessage(self) -> string getParam(self, *args) getParam(self, string name) -> string getStackTrace(self) getStackTrace(self) -> string getSummary(self) getSummary(self) -> string getType(self) getType(self) -> string hasCause(self) hasCause(self) -> bool line(self, *args) line(self, int val) -> StreamBaseException linkAsString(self) linkAsString(self) -> string message(self, *args) message(self, string val) -> StreamBaseException param(self, *args) param(self, string name, string val) -> StreamBaseException param(self, string name, int val) -> StreamBaseException summary(self, *args) summary(self, string val) -> StreamBaseException type(self, *args) type(self, string val) -> StreamBaseException what(self) what(self) -> char   sb::StreamBaseException::what Returns the message as a C string.     The string is owned by this object, so the pointer becomes invalid upon destruction of the StreamBaseException. Data descriptors inherited from StreamBaseException: __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__(...) __setstate__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args   class BoolVector(__builtin__.object)     Proxy of C++ std::vector<(bool)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> BoolVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> BoolVector __init__(self, *args) __init__(self) -> BoolVector __init__(self, BoolVector arg0) -> BoolVector __init__(self, size_type size) -> BoolVector __init__(self, size_type size, value_type value) -> BoolVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, BoolVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, BoolVector v = std::vector< bool,std::allocator< bool > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, BoolVector v) 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: __swig_destroy__ = <built-in function delete_BoolVector> delete_BoolVector(BoolVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Client(__builtin__.object)     The StreamBase client API.     Connects to an StreamBase node over the network, via XML/RPC and the tuple wire protocol. With the exception of the close() method, the StreamBaseClient object is not thread safe, so access to a single object needs to be synchronized between threads. If multiple threads subscribe to streams, it is recommended that they use separate instances of this class.     C++ includes: StreamBaseClient.hpp     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) StreamBaseClient(URI uri = sb::StreamBaseURI::fromEnvironment(), int buffer_size = 0,      int flush_interval = DEFAULT_FLUSH_INTERVAL) -> Client StreamBaseClient(URI uri = sb::StreamBaseURI::fromEnvironment(), int buffer_size = 0) -> Client StreamBaseClient(URI uri = sb::StreamBaseURI::fromEnvironment()) -> Client StreamBaseClient() -> Client StreamBaseClient(string uris, int buffer_size = 0, int flush_interval = DEFAULT_FLUSH_INTERVAL) -> Client StreamBaseClient(string uris, int buffer_size = 0) -> Client StreamBaseClient(string uris) -> Client StreamBaseClient(URIVector uris, int buffer_size = 0, int flush_interval = DEFAULT_FLUSH_INTERVAL) -> Client StreamBaseClient(URIVector uris, int buffer_size = 0) -> Client StreamBaseClient(URIVector uris) -> Client StreamBaseClient(URIVector uris, ClientSettings settings, int buffer_size = 0,      int flush_interval = DEFAULT_FLUSH_INTERVAL) -> Client StreamBaseClient(URIVector uris, ClientSettings settings, int buffer_size = 0) -> Client __init__(self, URIVector uris, ClientSettings settings) -> Client   sb::StreamBaseClient::StreamBaseClient __repr__ = _swig_repr(self) __setattr__ lambda self, name, value canDequeue(self) canDequeue(self) -> bool   sb::StreamBaseClient::canDequeue Return true if we can call dequeue without blocking.     This means that there is something to dequeue from the server. This dequeued item could be Tuples, a null (server shutdown) or an exception.     Returns ------- boolean if we can dequeue without blocking checkLicense(self, *args) checkLicense(self, string featureName) -> bool close(self) close(self)   sb::StreamBaseClient::close Terminate the client.     May be invoked from a different thread. StreamBaseClient memory, network, and thread resources are not released until close() is called.     Returns immediately. dequeue(self, *args) dequeue(self) -> DequeueResult dequeue(self, int timeout_ms) -> DequeueResult   Dequeue tuples from any subscribed stream   This method blocks until at least one tuple is available on any subscribed stream, or the StreamBase server is shut down. describe(self, *args) describe(self, string entity) -> string   sb::StreamBaseClient::describe Returns an XML description of an entity, or an empty string if the method does not exist. doByteSwap(self) doByteSwap(self) -> bool enableBuffering(self, *args) enableBuffering(self, int buffer_size, int flush_interval = DEFAULT_FLUSH_INTERVAL) enableBuffering(self, int buffer_size)   sb::StreamBaseClient::enableBuffering Turn on buffering. The WakeAndFlushBuffer thread is only started if flush_interval > 0. enableConnectionlessEnqueue(self, *args) enableConnectionlessEnqueue(self, bool enable) enableHeartbeating(self) enableHeartbeating(self)   sb::StreamBaseClient::enableHeartbeating Enable heartbeating for this client. Generally this is only for enqueue-only clients. enqueue(self, *args) enqueue(self, string stream_name, Tuple tuple) enqueue(self, StreamProperties props, Tuple tuple) enqueue(self, string stream_name, TupleList tuples) enqueue(self, StreamProperties props, TupleList tuples)   enqueue(self, string stream_name, (tuple,list,dict) pyTuple) enqueue(self, StreamProperties props, (tuple,list,dict) pyTuple)   Enqueue tuples to an input stream.   This method may block due to network congestion or StreamBase server congestion.   If provided a Python tuple, list, or dict, enqueue will attempt to convert it to a Tuple object using the Schema of the target stream before sending it to the server. flushAllBuffers(self) flushAllBuffers(self)   sb::StreamBaseClient::flushAllBuffers Flush any pending enqueue buffers.     This operation has no effect if buffering is not enabled.     Exceptions ---------- * `StreamBaseException` :       if there is an IO error while flushing the buffer flushBuffer(self, *args) flushBuffer(self, StreamProperties props) flushBuffer(self, string stream_name)   sb::StreamBaseClient::flushBuffer Flush any pending enqueue buffer for the stream name provided.     This operation has no effect if buffering is not enabled or there is no buffer to flush for the given stream.   **Note:** Note that this will cause inter- stream ordering to be interrupted.     Parameters ---------- * `stream_name` :       the stream whose enqueue buffers to flush, if not empty     Exceptions ---------- * `StreamBaseException` :       if there is an IO error while flushing the buffer   Deprecated stream_name use StreamProperties based flushBuffer     use flushAllBuffers() to preserve inter-stream ordering getBufferSize(self) getBufferSize(self) -> int   sb::StreamBaseClient::getBufferSize Return buffer size (in tuples) getConnectionID(self) getConnectionID(self) -> string   sb::StreamBaseClient::getConnectionID Return the Connection ID for this Client Connection.     Only Valid once an enqueue/dequeue has been attempted.     Returns ------- connection ID in binary format getConnectionIdAsHexString(self) getConnectionIdAsHexString(self) -> string   sb::StreamBaseClient::getConnectionIdAsHexString Return the Connection ID for this Client Connection.     Only Valid once an enqueue/dequeue has been attempted.     Returns ------- connection ID in Hexadecimal format getDynamicVariables(self, *args) getDynamicVariables(self, string modulePath) -> Tuple   sb::StreamBaseClient::getDynamicVariables Get all the dynamic variables in the given module, and return them as a Tuple where the field names are the names of the dynamic variables, and the field values are the current values of the dynamic variables.     Exceptions ---------- * `StreamBaseException` :       on network or other errors, or if there are no dynamic variables in the     named module getIsBuffering(self) getIsBuffering(self) -> bool   sb::StreamBaseClient::getIsBuffering Return whether buffering is turned on or off. getIsConnectionlessEnqueue(self) getIsConnectionlessEnqueue(self) -> bool getSchemaByHash(self, *args) getSchemaByHash(self, string hash) -> Schema   sb::StreamBaseClient::getSchemaByHash Returns a schema with a particular hash. getSchemaByName(self, *args) getSchemaByName(self, string name) -> Schema   sb::StreamBaseClient::getSchemaByName Returns a schema by name.     This will only succeed for named schemas; anonymous schemas assigned to a port should instead be looked up via getStreamProperties().getSchema(). getSchemaForStream(self, *args) getSchemaForStream(self, string entity, CaptureTransformStrategy strategy = FLATTEN) -> Schema getSchemaForStream(self, string entity) -> Schema   sb::StreamBaseClient::getSchemaForStream Returns the schema of a stream, throwing an exception if the stream does not exist. getSettings(self) getSettings(self) -> ClientSettings   sb::StreamBaseClient::getSettings Get the settings for the client. getStreamProperties(self, *args) getStreamProperties(self, string entity, CaptureTransformStrategy strategy = FLATTEN) -> StreamProperties getStreamProperties(self, string entity) -> StreamProperties   sb::StreamBaseClient::getStreamProperties Returns a description of a stream, throwing an exception if the stream does not exist.     Parameters ---------- * `entity` :       the path of the stream   * `strategy` :       how to handle capture fields on the stream getStreamPropertiesByHash(self, *args) getStreamPropertiesByHash(self, string hex) -> StreamProperties   sb::StreamBaseClient::getStreamPropertiesByHash Returns a description of a stream, throwing an exception if the stream does not exist. getTupleDequeueCount(self) getTupleDequeueCount(self) -> long long   sb::StreamBaseClient::getTupleDequeueCount Returns the number of tuples this client has dequeued from the server.     This number does not include tuples that may be dequeued as part of system services such as heartbeating. This number does however include tuples that have been dequeued but have been intercepted by the Interceptor. getTupleEnqueueCount(self) getTupleEnqueueCount(self) -> long long   sb::StreamBaseClient::getTupleEnqueueCount Returns the number of tuples this client has actually enqueued to the server.     Note that this number will not include any tuples that have been buffered but have not actually been enqueued to the server. getURI(self) getURI(self) -> URI   sb::StreamBaseClient::getURI Return the URI we're talking to. getURIs(self) getURIs(self) -> URIVector   sb::StreamBaseClient::getURIs getVersion(self) getVersion(self) -> string   sb::StreamBaseClient::getVersion Returns the client version as a string. internalCommand(self, *args) internalCommand(self, StringVector arguments) isClosed(self) isClosed(self) -> bool   sb::StreamBaseClient::isClosed Return true if the client connection is closed.     The client connection can be closed by calling the close() method, or by a server shutdown, or a network error. isConnected(self) isConnected(self) -> bool   sb::StreamBaseClient::isConnected Returns true if this TupleConnections has any live connections to a server.     Note that a return of "false" doesn't necessarily indicate an error since the TupleConnection's state (e.g., lack of subscriptions) might mean no connections are needed.     Returns ------- boolean if we are connected isStreamSubscribed(self, *args) isStreamSubscribed(self, string entity) -> bool   sb::StreamBaseClient::isStreamSubscribed Returns true if this stream has been subscribed to.     Parameters ---------- * `entity` :       the path of the stream listEntities(self, *args) listEntities(self, string type, int flags) listEntities(self, Type type, int flags) listEntities(self, Type type)   sb::StreamBaseClient::listEntities Lists all entities of a particular type.     (One can then use "describe" to obtain a description of an entity.) names is cleared first. operatorStatus(self, *args) operatorStatus(self, string containerName)   -> a list of the the statuses of Java operators and adapters as strings readTable(self, *args) readTable(self, string tablePath, int limit, string predicate = "") -> TupleList readTable(self, string tablePath, int limit) -> TupleList   sb::StreamBaseClient::readTable Read rows out of the table at this path.     Limit to the specified number of rows returned, or -1 for no limit. Filter rows according to predicate, or return all rows if predicate is empty.     Returns ------- a list of matching rows. resubscribe(self, *args) resubscribe(self, string stream_name, string logical_stream, string predicate) -> StreamProperties resubscribe(self, StreamProperties props, string logical_stream, string predicate) -> StreamProperties   sb::StreamBaseClient::resubscribe Resubscribes to an already subscribed stream.     Returns ------- the StreamProperties for the stream setDynamicVariable(self, *args) setDynamicVariable(self, string dynamicVariablePath, string value)   sb::StreamBaseClient::setDynamicVariable Set the dynamic variable at the given path to the given value, expressed as a string in CSV style.     Exceptions ---------- * `StreamBaseException` :       if the dynamic variable does not exist, or the value is not appropriate for     setting the dynamic variable setQuiescentLimit(self, *args) setQuiescentLimit(self, int timeoutMS) -> int   sb::StreamBaseClient::setQuiescentLimit Sets how many milliseconds a dequeueing client will tolerate not receiving a client heart beat from the StreamBase server that it is connected to.     The default value is 120 seconds (120000). By default, StreamBase servers emit "client heart beats" every 10 seconds so StreamBase applications have no requirement to send data regularly.     Parameters ---------- * `timeoutMS` :       The number of milliseconds that is allowed to pass without receiving a     message from the StreamBase server client heart beat stream. status(self, verbose=False) status(self, bool verbose = False) status(self)   sb::StreamBaseClient::status status the streambase daemons subscribe(self, *args) subscribe(self, string stream_name) -> StreamProperties subscribe(self, StreamProperties props) -> StreamProperties subscribe(self, string stream_name, string logical_stream, string predicate) -> StreamProperties subscribe(self, StreamProperties props, string logical_stream, string predicate) -> StreamProperties   sb::StreamBaseClient::subscribe Subscribes to a stream with a predicate to apply to output tuples.         The stream name of dequeued tuples is logical_stream. When unsubscribing, use logical_stream.     Parameters ---------- * `props` :       the stream to subscribe to, error if empty   * `logical_stream` :       the name of the logical stream to associate with this predicate (if empty,     defaults to streamname)   * `predicate` :       a predicate to apply to subset the stream, error if empty     Returns ------- the StreamProperties for the stream typecheck(self, *args) typecheck(self, string sbapp, bool full = False) typecheck(self, string sbapp)   sb::StreamBaseClient::typecheck Typechecks a potential modification to the application, outputting properties of all streams in the application.     streams is cleared first.     Parameters ---------- * `sbapp` :       the application   * `streams` :       the schema defs of the streams   * `full` :       do a full typecheck unsubscribe(self, *args) unsubscribe(self, string stream_name) unsubscribe(self, StreamProperties props)   sb::StreamBaseClient::unsubscribe UnSubscribes to a stream.     Note: Any tuples that are in-flight during an unsubscribe request will be dequeued until the stream is fully drained. Data descriptors defined here: __dict__ dictionary for instance variables (if defined) __weakref__ list of weak references to the object (if defined) useRawTuples Data and other attributes defined here: ALL_CONTAINERS = 5 DEFAULT_FLUSH_INTERVAL = 250 FULLY_QUALIFIED_NAMES = 1 INCLUDE_MODULES = 2 __swig_destroy__ = <built-in function delete_Client> delete_Client(Client self)   sb::StreamBaseClient::~StreamBaseClient Destroys a session. __swig_getmethods__ = {'useRawTuples': <built-in function Client_useRawTuples_get>} __swig_setmethods__ = {'useRawTuples': <built-in function Client_useRawTuples_set>}   class ClientSettings(__builtin__.object)     This class loads all the environment variables used by the C++ client API.     It uses a global static object to do the work.     C++ includes: ClientSettings.hpp     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self, bool haModeOn) -> ClientSettings   sb::ClientSettings::ClientSettings Loads all the client settings. __repr__ = _swig_repr(self) __setattr__ lambda self, name, value checkClientExitStatus(self) checkClientExitStatus(self) -> bool   sb::ClientSettings::checkClientExitStatus Should we check the client exit status.     Returns ------- if we should check the client exit status getExitStatusTimeout(self) getExitStatusTimeout(self) -> NMSTL::Time   sb::ClientSettings::getExitStatusTimeout Get the timeout used when sending a request to the server to get the clients exit status.     Returns ------- Time (in milliseconds) of the time to wait for the clients exit status getHeartbeatTimeout(self) getHeartbeatTimeout(self) -> NMSTL::Time   sb::ClientSettings::getHeartbeatTimeout Get the heart beat timeout.     Returns ------- Time (in milliseconds) the tuple quiesent timeout getMaxDequeuerQueueSize(self) getMaxDequeuerQueueSize(self) -> unsigned int   sb::ClientSettings::getMaxDequeuerQueueSize getMaxInputPacketSize(self) getMaxInputPacketSize(self) -> unsigned int   sb::ClientSettings::getMaxInputPacketSize Get the maximum size of the input tuple in binary mode.     Returns ------- max size of the input tuple (in bytes) getMaxTupleBufferCacheSize(self) getMaxTupleBufferCacheSize(self) -> unsigned int   sb::ClientSettings::getMaxTupleBufferCacheSize getOpenTimeout(self) getOpenTimeout(self) -> NMSTL::Time   sb::ClientSettings::getOpenTimeout Get the timeout used when opening a connection.     Returns ------- Time (in milliseconds) that the tuple i/o will wait before assuming the server is down. getReconnectSleep(self) getReconnectSleep(self) -> NMSTL::Time   sb::ClientSettings::getReconnectSleep Get the amount of time to sleep between reconnect requests.     Returns ------- Time (in milliseconds) to sleep between reconnect timeouts in the event that the TupleConnection is disconnected from its server. getWriteTimeout(self) getWriteTimeout(self) -> NMSTL::Time   sb::ClientSettings::getWriteTimeout Get the timeout used when writing to a connection.     Returns ------- Time (in milliseconds) that the tuple i/o will wait before assuming the server is down. getXmlRpcTimeout(self) getXmlRpcTimeout(self) -> NMSTL::Time   sb::ClientSettings::getXmlRpcTimeout Get the timeout used when making an xmlrpc request.     Returns ------- Time (in milliseconds) that the tuple i/o will wait before assuming the server is down. setExitStatusTimeout(self, *args) setExitStatusTimeout(self, NMSTL::Time exitStatusTimeout)   sb::ClientSettings::setExitStatusTimeout Set the timeout used when sending a request to the server to get the clients exit status.     Parameters ---------- * `exitStatusTimeout` :       new value (in milliseconds) for the exit status timeout setHeartbeatTimeout(self, *args) setHeartbeatTimeout(self, NMSTL::Time heartbeatTimeout)   sb::ClientSettings::setHeartbeatTimeout Set the heart beat timeout.     Parameters ---------- * `heartbeatTimeout` :       new value (in milliseconds) for the heartbeat timeout setMaxDequeuerQueueSize(self, *args) setMaxDequeuerQueueSize(self, unsigned int maxDequeuerQueueSize)   sb::ClientSettings::setMaxDequeuerQueueSize Set the maximum number of tuples to be kept in the Dequeuer Thread's internal queue before applying back-pressure to the server.     Parameters ---------- * `maxDequeuerQueueSize` :       maximum number of tuples to allow to wait in the Dequeuer Thread's internal     queue before blocking dequeues from the server. setMaxInputPacketSize(self, *args) setMaxInputPacketSize(self, unsigned int maxInputPacketSize)   sb::ClientSettings::setMaxInputPacketSize Set the maximum size of the input tuple in binary mode.     Parameters ---------- * `maxInputPacketSize` :       new value (in milliseconds) for the maxInputPacket size setOpenTimeout(self, *args) setOpenTimeout(self, NMSTL::Time tupleOpenTimeout)   sb::ClientSettings::setOpenTimeout Set the timeout used when opening a binary connection.     Parameters ---------- * `tupleOpenTimeout` :       new value (in milliseconds) for the tuple open timeout setReconnectSleep(self, *args) setReconnectSleep(self, NMSTL::Time reconnectSleep)   sb::ClientSettings::setReconnectSleep Set the amount of time to sleep between reconnect requests.     Parameters ---------- * `reconnectSleep` :       new value (in milliseconds) for reconnect sleep setTcpNoDelay(self, *args) setTcpNoDelay(self, bool tcpNoDelay)   sb::ClientSettings::setTcpNoDelay Enable/disable TCP_NO_DELAY.     Parameters ---------- * `tcpNoDelay` :       enable/disable TCP_NO_DELAY setWriteTimeout(self, *args) setWriteTimeout(self, NMSTL::Time tupleWriteTimeout)   sb::ClientSettings::setWriteTimeout Set the timeout used when writing to a connection.     Parameters ---------- * `tupleWriteTimeout` :       new value (in milliseconds) for the tuple write timeout setXmlRpcTimeout(self, *args) setXmlRpcTimeout(self, NMSTL::Time xmlrpcTimeout)   sb::ClientSettings::setXmlRpcTimeout Set the timeout used when making an xmlrpc request.     Parameters ---------- * `xmlrpcTimeout` :       new value (in milliseconds) for the xmlrpc request timeout tcpNoDelay(self) tcpNoDelay(self) -> bool   sb::ClientSettings::tcpNoDelay Is TCP_NODELAY set.     Returns ------- if tcpNoDealy set 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: __swig_destroy__ = <built-in function delete_ClientSettings> delete_ClientSettings(ClientSettings self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class CompleteDataType(__builtin__.object)     An object containing all the information about a data type -- the primitive DataType; for DataType::TUPLEs, the Tuple's Schema; and for DataType::LISTs, the List elements' own CompleteDataType.     To get a CompleteDataType object, call the type-appropriate static method, eg. for a Boolean CompleteDatatType object, call CompleteDataType::forBool(); for a Tuple CompleteDataType, call CompleteDataType::forTuple(s) with some Schema s; for a List CompleteDataType, call CompleteDataType::forList(cdt) with some CompleteDataType cdt; and so on.     CompleteDataTypes are immutable; once created they may not be changed.     C++ includes: CompleteDataType.hpp     Methods defined here: __del__ lambda self __eq__(self, *args) x.__eq__(y) <==> x==y __ge__(self, *args) x.__ge__(y) <==> x>=y __getattr__ lambda self, name __gt__(self, *args) x.__gt__(y) <==> x>y __init__(self, *args) __init__(self) -> CompleteDataType __init__(self, CompleteDataType cdt) -> CompleteDataType   sb::CompleteDataType::CompleteDataType Copy constructor. __le__(self, *args) x.__le__(y) <==> x<=y __lt__(self, *args) x.__lt__(y) <==> x<y __ne__(self, *args) x.__ne__(y) <==> x!=y __nonzero__(self) x.__nonzero__() <==> x != 0 __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self) x.__str__() <==> str(x)   sb::CompleteDataType::as_string Returns a string representation of this CompleteDataType. compare(self, *args) compare(self, CompleteDataType fv) -> int   sb::CompleteDataType::compare Compare the current CompleteDataType against the provided CompleteDataType by base type (eg DataType::BOOL, INT, ::TUPLE, etc).     Therefore, for example a LIST of type INT and a LIST of type TUPLE are equal.     Returns ------- -1 if the current CompleteDataType is less than the provided CompleteDataType, 0 if the current is equal to the provided CompleteDataType, and 1 if the current is greater than the provided CompleteDataType. getArgumentSchema(self) getArgumentSchema(self) -> Schema   If this CompleteDataType has an argument schema, returns it For all other types, returns None. getCaptureTypeName(self) getCaptureTypeName(self) -> string   sb::CompleteDataType::getCaptureTypeName getElementCompleteType(self) getElementCompleteType(self) -> CompleteDataType   If this CompleteDataType has an element type, returns the element's CompleteDataType.  For all other types, returns None. getReturnType(self) getReturnType(self) -> CompleteDataType   If this CompleteDataType has a return type, returns it as a CompleteDataType.  For all other types, returns None. getSchema(self) getSchema(self) -> Schema   sb::CompleteDataType::getSchema If this CompleteDataType has a nested tuple, return its Schema.     For all other types, return a null Schema. getType(self) getType(self) -> DataType   sb::CompleteDataType::getType Return the primitive DataType of the CompleteDataType. hasElementType(self) hasElementType(self) -> bool   sb::CompleteDataType::hasElementType Returns true if this CompleteDataType has an element CompleteDataType (eg it is a DataType::LIST of DataType::INTs, the latter being its element type). hasSchema(self) hasSchema(self) -> bool   sb::CompleteDataType::hasSchema Returns true if this CompleteDataType contains a Schema (eg it is a DataType::TUPLE). Static methods defined here: forBlob() forBlob() -> CompleteDataType   sb::CompleteDataType::forBlob Return a CompleteDataType of type DataType::BLOB. forBool() forBool() -> CompleteDataType   sb::CompleteDataType::forBool Return a CompleteDataType of type DataType::BOOL. forCapture(*args) forCapture(string captureName) -> CompleteDataType   sb::CompleteDataType::forCapture Return a CompleteDataType of type DataType::CAPTURE with the given capture type name. forDouble() forDouble() -> CompleteDataType   sb::CompleteDataType::forDouble Return a CompleteDataType of type DataType::DOUBLE. forFunction(*args) forFunction(Schema argumentSchema, CompleteDataType returnType) -> CompleteDataType   sb::CompleteDataType::forFunction Return a CompleteDataType of type DataType::FUNCTION with the given argument schema and return type. forInt() forInt() -> CompleteDataType   sb::CompleteDataType::forInt Return a CompleteDataType of type DataType::INT. forList(*args) forList(CompleteDataType elemType) -> CompleteDataType   sb::CompleteDataType::forList Return a CompleteDataType of type DataType::LIST with the given CompleteDataType as the type of its elements. forLong() forLong() -> CompleteDataType   sb::CompleteDataType::forLong Return a CompleteDataType of type DataType::LONG. forSimpleType(*args) forSimpleType(DataType type) -> CompleteDataType   sb::CompleteDataType::forSimpleType Convenience method.     Return the CompleteDataType appropriate to the given DataType. Invalid on DataType::TUPLE and DataType::LIST, since they require extra information to fully specify their CompleteDataType. forString() forString() -> CompleteDataType   sb::CompleteDataType::forString Return a CompleteDataType of type DataType::STRING. forTimestamp() forTimestamp() -> CompleteDataType   sb::CompleteDataType::forTimestamp Return a CompleteDataType of type DataType::TIMESTAMP. forTuple(*args) forTuple(Schema s) -> CompleteDataType   sb::CompleteDataType::forTuple Return a CompleteDataType of type DataType::TUPLE with the given Schema. 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: __swig_destroy__ = <built-in function delete_CompleteDataType> delete_CompleteDataType(CompleteDataType self)   sb::CompleteDataType::~CompleteDataType Destructor. __swig_getmethods__ = {'forBlob': <function <lambda>>, 'forBool': <function <lambda>>, 'forCapture': <function <lambda>>, 'forDouble': <function <lambda>>, 'forFunction': <function <lambda>>, 'forInt': <function <lambda>>, 'forList': <function <lambda>>, 'forLong': <function <lambda>>, 'forSimpleType': <function <lambda>>, 'forString': <function <lambda>>, ...} __swig_setmethods__ = {}   class DataType(__builtin__.object)     A type of data in a tuple.     Valid values are     *   DataType::NONE (sentinel "null" value)   *   DataType::INT   *   DataType::DOUBLE   *   DataType::STRING   *   DataType::TIMESTAMP   *   DataType::BOOL   *   DataType::LONG   *   DataType::BLOB   *   DataType::TUPLE   *   DataType::LIST   *   DataType::CAPTURE   *   DataType::FUNCTION     C++ includes: DataType.hpp     Methods defined here: __del__ lambda self __eq__(self, other) x.__eq__(y) <==> x==y __ge__(self, other) x.__ge__(y) <==> x>=y __getattr__ lambda self, name __gt__(self, other) x.__gt__(y) <==> x>y __init__(self, *args) __init__(self) -> DataType __init__(self, Rep type) -> DataType   sb::DataType::DataType Construct a DataType equal to DataType::NONE. __int__(self) x.__int__() <==> int(x) __le__(self, other) x.__le__(y) <==> x<=y __lt__(self, other) x.__lt__(y) <==> x<y __ne__(self, other) x.__ne__(y) <==> x!=y __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self) x.__str__() <==> str(x)   sb::DataType::as_string Return a string representation of the data type. getSize(self) getSize(self) -> size_t   sb::DataType::getSize Static methods defined here: isFixedSize(*args) isFixedSize(DataType type) -> bool   sb::DataType::isFixedSize Return false if the type is variable-length (e.g., STRING or BLOB) 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: BLOB = 14 BOOL = 12 CAPTURE = 17 DOUBLE = 8 FUNCTION = 18 INT = 7 LIST = 16 LONG = 13 NONE = 0 STRING = 10 TIMESTAMP = 11 TUPLE = 15 __swig_destroy__ = <built-in function delete_DataType> delete_DataType(DataType self) __swig_getmethods__ = {'isFixedSize': <function <lambda>>} __swig_setmethods__ = {}   class DequeueResult(__builtin__.object)     Encapsulates the data returned from a dequeue() operation.     Contains a stream name and a list of tuples.     C++ includes: DequeueResult.hpp     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self) -> DequeueResult __init__(self, StreamProperties props, TupleList tuples, URI serverURI,      LeadershipStatus _leadershipStatus) -> DequeueResult   sb::DequeueResult::DequeueResult Create a Dequeue Result with a list of tuples, with the given LeadershipStatus. __repr__ = _swig_repr(self) __setattr__ lambda self, name, value getLeadershipStatus(self) getLeadershipStatus(self) -> LeadershipStatus   sb::DequeueResult::getLeadershipStatus Return the leadership status of the server that produced this dequeue result. getServerURI(self) getServerURI(self) -> URI   Returns the URI of the server that produced these results. getStatus(self) getStatus(self) -> Status   sb::DequeueResult::getStatus Return the status of this DequeueResult.     DequeueResult::GOOD means the DequeueResult contains tuples.     Returns ------- the status of this DequeueResult getStreamName(self) getStreamName(self) -> string   sb::DequeueResult::getStreamName Returns the name of the stream on which tuples were dequeued. getStreamProperties(self) getStreamProperties(self) -> StreamProperties   Returns the StreamProperties for this DequeueResult. getTuple(self, *args) getTuple(self, int index) -> Tuple   Returns the index'th tuple. getTupleCount(self) getTupleCount(self) -> int   sb::DequeueResult::getTupleCount Returns the number of tuples dequeued. getTuples(self) getTuples(self) -> TupleList   Returns the list of tuples. reuseTuple(self) reuseTuple(self)   sb::DequeueResult::reuseTuple Currently a no-op maintained for backwards compatibility.     Deprecated 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: CLOSED = 3 GOOD = 1 TIMEOUT = 2 UNINITIALIZED = 0 __swig_destroy__ = <built-in function delete_DequeueResult> delete_DequeueResult(DequeueResult self)   sb::DequeueResult::~DequeueResult __swig_getmethods__ = {} __swig_setmethods__ = {}   class DoubleVector(__builtin__.object)     Proxy of C++ std::vector<(double)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> DoubleVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> DoubleVector __init__(self, *args) __init__(self) -> DoubleVector __init__(self, DoubleVector arg0) -> DoubleVector __init__(self, size_type size) -> DoubleVector __init__(self, size_type size, value_type value) -> DoubleVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, DoubleVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, DoubleVector v = std::vector< double,std::allocator< double > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, DoubleVector v) 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: __swig_destroy__ = <built-in function delete_DoubleVector> delete_DoubleVector(DoubleVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class EntityType(__builtin__.object)     A type of entity in a StreamBase catalog.     C++ includes: StreamBaseEntityType.hpp     Methods defined here: __getattr__ lambda self, name __init__(self, *args, **kwargs) __repr__ = _swig_repr(self) __setattr__ lambda self, name, value Static methods defined here: __str__(*args) x.__str__() <==> str(x)   sb::StreamBaseEntityType::as_string Return a string naming the entity type. as_enum(*args) as_enum(string aType, bool allow_plural = False) -> Type as_enum(string aType) -> Type   sb::StreamBaseEntityType::as_enum Parse a string as an entity type.     Parameters ---------- * `aType` :       the string to parse   * `allow_plural` :       true if a plural version of the entity types (e.g., "streams" instead of     "stream") is allowed     Exceptions ---------- * `StreamBaseException` :       if the entity type cannot be parsed 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: CONTAINER = 5 INPUT_STREAMS = 100 OPERATOR = 3 OUTPUT_STREAMS = 101 SCHEMA = 2 STREAM = 1 TABLE = 6 WINDOW_SPEC = 4 __swig_getmethods__ = {'__str__': <function <lambda>>, 'as_enum': <function <lambda>>} __swig_setmethods__ = {}   class Errors(__builtin__.object)     Proxy of C++ sb_internal::Errors class     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self) __init__(self) -> Errors __repr__ = _swig_repr(self) __setattr__ lambda self, name, value 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: ADAPTER_ERROR = 24 AUTHENTICATION_ERROR = 9 CHECKPOINT_CONSUMPTION_ERROR = 20 CHECKPOINT_CREATION_ERROR = 19 CHECKPOINT_ERROR = 17 CHECKPOINT_SETUP_ERROR = 18 CLUSTER_NETWORK_ERROR = 16 CONFIG_ERROR = 15 CONTAINER_ERROR = 25 DB_ERROR = 8 EVAL_ERROR = 2 EVAL_PLUGIN_ERROR = 13 EXPR_ERROR = 10 FATAL_ERROR = 1 HA_IO_ERROR = 22 MEM_ERROR = 3 NETWORK_ERROR = 4 NON_FATAL_ERROR = 1000 ORDERING_ERROR = 23 PAGE_POOL_ERROR = 21 PLUGIN_ERROR = 12 SHUTDOWN_ACTION = 'shutdown' STREAM_NAME = 'system.error' TUPLE_ERROR = 14 TYPECHECK_ERROR = 6 UNKNOWNTYPE = 0 USAGE_ERROR = 11 XMLRPC_ERROR = 7 XML_ERROR = 5 __swig_destroy__ = <built-in function delete_Errors> delete_Errors(Errors self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Field(__builtin__.object)     Information (name, type, and optionally size) about a field in a Schema.     A field can be looked up within a schema in three ways:     1.  By index: By the zero-based ordinal position of the field within the schema   2.  By simple name: By the name of the field itself (e.g., "myint")   3.  By path name: By a dot-separated list of names that define a path through a     set of nested schemas that arise through the use of fields of type Tuple     (e.g., "mynestedtuple.myint").     A Field object can be used to obtain the value of a field in a tuple. However, there are rules that must be obeyed in doing so. For example, one must obtain the Field object from a Schema object that describes the schema of the tuple (i.e., as opposed to directly from a Field constructor).     See the "client" StreamBase sample (*streambase-install-dir*/sample/client) for examples of proper use of Field objects.     C++ includes: Field.hpp     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self) -> Field __init__(self, string name, DataType type, size_t size = (size_t) -1) -> Field __init__(self, string name, DataType type) -> Field __init__(self, string name, DataType type, Schema schema) -> Field __init__(self, string name, CompleteDataType cdt) -> Field __init__(self, Field f) -> Field   sb::Field::Field Copy constructor. __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self) x.__str__() <==> str(x)   sb::Field::as_string Returns a string representation of a field. as_xml(self) as_xml(self) -> string getArgumentSchema(self) getArgumentSchema(self) -> Schema   sb::Field::getArgumentSchema getCompleteType(self) getCompleteType(self) -> CompleteDataType   sb::Field::getCompleteType Returns the complete type of a field (e.g., DataType::LIST of DataType::INTs). getElementCompleteType(self) getElementCompleteType(self) -> CompleteDataType   sb::Field::getElementCompleteType Returns the complete type of a field's elements (e.g., on a DataType::LIST of DataType::INTs, returns a CompleteDataType of DataType::INT). getFieldPath(self) getFieldPath(self) -> FieldVector   sb::Field::getFieldPath getFixedSize(self) getFixedSize(self) -> size_t   sb::Field::getFixedSize Returns the size of a field if it has a fixed size or -1. getIndex(self) getIndex(self) -> int   sb::Field::getIndex Returns the index of the field. getName(self) getName(self) -> string   sb::Field::getName Returns the name of a field. getReturnType(self) getReturnType(self) -> CompleteDataType   sb::Field::getReturnType getSchema(self) getSchema(self) -> Schema   sb::Field::getSchema Returns the field's schema (valid only if the field's type is TUPLE) getType(self) getType(self) -> DataType   sb::Field::getType Returns the type of a field (e.g., DataType::INT). sameType(self, *args) sameType(self, Field other) -> bool   sb::Field::sameType Return true if the fields are the same type (including size information) 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: LIST_HEADER_SIZE = 8 NESTED_TUPLE_HEADER_SIZE = 4 STRING_HEADER_SIZE = 4 VARLEN_HEADER_SIZE = 4 __swig_destroy__ = <built-in function delete_Field> delete_Field(Field self)   sb::Field::~Field __swig_getmethods__ = {} __swig_setmethods__ = {}   class FieldValue(__builtin__.object)         A value a Field may take on.         Also possibly a list element.        Has a type and some information of said type.         FieldValues are immutable. Calling an inappropriate getter will cause an error.         ` FieldValue fv(5); // this creates a FieldValue of DataType::INT        cout << fv.getInt() << " ";        cout << fv.getBool() << " ";  `         The first `cout` line will succeed; the second will throw an exception.         C++ includes: FieldValue.hpp     Methods defined here: __del__ lambda self __eq__(self, *args) x.__eq__(y) <==> x==y __ge__(self, *args) x.__ge__(y) <==> x>=y __getattr__ lambda self, name __gt__(self, *args) x.__gt__(y) <==> x>y __init__(self, *args) __init__(self) -> FieldValue of type NONE __init__(self, CompleteDataType cdt) -> FieldValue fv of type      cdt, for which fv.isNull() == True __init__(self, bool value) -> FieldValue of type BOOL __init__(self, int value) -> FieldValue of type INT __init__(self, double value) -> FieldValue of type DOUBLE __init__(self, long long value) -> FieldValue of type LONG __init__(self, Timestamp value) -> FieldValue of type TIMESTAMP __init__(self, char value) -> FieldValue of type STRING __init__(self, string value) -> FieldValue of type STRING __init__(self, DataType type, string value) -> FieldValue of      type BLOB if type == BLOB  __init__(self, Tuple value) -> FieldValue of type TUPLE __init__(self, FieldValueVector value) -> FieldValue of type LIST __init__(self, FieldValue fv) -> FieldValue __le__(self, *args) x.__le__(y) <==> x<=y __lt__(self, *args) x.__lt__(y) <==> x<y __ne__(self, *args) x.__ne__(y) <==> x!=y __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self) x.__str__() <==> str(x)   sb::FieldValue::as_string Return a string representation of this FieldValue. compare(self, *args) compare(self, FieldValue fv) -> int   sb::FieldValue::compare Compare the current FieldValue against the provided FieldValue.     Null FieldValues are less than non-null FieldValues. Provides a total ordering over the set of possible FieldValues, so does not check types. Ordering of FieldValues of heterogeneous types is not guaranteed but is consistent.     Returns ------- -1 if the current FieldValue is less than the provided FieldValue, 0 if the current is equal to the provided FieldValue, and 1 if the current is greater than the provided FieldValue. getBlob(self) getBlob(self) -> string   sb::FieldValue::getBlob Return the value of a blob FieldValue as a string.         Will throw an exception if this FieldValue is not of type DataType::BLOB. getBool(self) getBool(self) -> bool   sb::FieldValue::getBool Return the value of a boolean FieldValue.         Will throw an exception if this FieldValue is not of type DataType::BOOL. getCapture(self) getCapture(self) -> string   sb::FieldValue::getCapture Return the value of a Capture FieldValue, as a string Will throw an exception if this FieldValue is not of type DataType::CAPTURE. getCompleteType(self) getCompleteType(self) -> CompleteDataType   Returns the CompleteDataType of this FieldValue. getDouble(self) getDouble(self) -> double   sb::FieldValue::getDouble Return the value of a double FieldValue.         Will throw an exception if this FieldValue is not of type DataType::DOUBLE. getFunction(self) getFunction(self) -> Function   sb::FieldValue::getFunction Return the value of a Function FieldValue Will throw an exception if this FieldValue is not of type DataType::FUNCTION. getInt(self) getInt(self) -> int   sb::FieldValue::getInt Return the value of an integer FieldValue.         Will throw an exception if this FieldValue is not of type DataType::INT. getList(self) getList(self) -> FieldValueVector   Returns the value of a List FieldValue. getLong(self) getLong(self) -> long long   sb::FieldValue::getLong Return the value of a long FieldValue.         Will throw an exception if this FieldValue is not of type DataType::LONG. getSize(self) getSize(self) -> size_t getString(self) getString(self) -> string   sb::FieldValue::getString Return the value of a string FieldValue.         Will throw an exception if this FieldValue is not of type DataType::STRING. getTimestamp(self) getTimestamp(self) -> Timestamp   sb::FieldValue::getTimestamp Return the value of a Timestamp FieldValue as a Timestamp.         Will throw an exception if this FieldValue is not of type DataType::TIMESTAMP. getTuple(self) getTuple(self) -> Tuple   Returns the value of a Tuple FieldValue. getType(self) getType(self) -> DataType   sb::FieldValue::getType Get the primitive DataType of this FieldValue. isNull(self) isNull(self) -> bool   sb::FieldValue::isNull Return true if this FieldValue represents a null value. sameType(self, *args) sameType(self, FieldValue fv) -> bool   sb::FieldValue::sameType Returns true if this FieldValue and the provided FieldValue are of the same type.     "Of the same type" is defined as their CompleteDataType members being equivalent. toCSVString(self, *args) toCSVString(self, char delim, string null_string, char quote) -> string toDelimitedString(self, *args) toDelimitedString(self, string delimiter, string null_string, bool include_names,      bool quote_all_strings) -> string Static methods defined here: forLong(*args) forLong(long long val) -> FieldValue getFalse() getFalse() -> FieldValue getTrue() getTrue() -> FieldValue 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: __swig_destroy__ = <built-in function delete_FieldValue> delete_FieldValue(FieldValue self)   sb::FieldValue::~FieldValue Destructor. __swig_getmethods__ = {'forLong': <function <lambda>>, 'getFalse': <function <lambda>>, 'getTrue': <function <lambda>>} __swig_setmethods__ = {} skip_finalize = <class 'streambase.skip_finalize'>   class FieldValueVector(__builtin__.object)     Proxy of C++ std::vector<(sb::FieldValue)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> FieldValueVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> FieldValueVector __init__(self, *args) __init__(self) -> FieldValueVector __init__(self, FieldValueVector arg0) -> FieldValueVector __init__(self, size_type size) -> FieldValueVector __init__(self, size_type size, value_type value) -> FieldValueVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, FieldValueVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, FieldValueVector v = std::vector< sb::FieldValue,std::allocator< sb::FieldValue > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, FieldValueVector v) 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: __swig_destroy__ = <built-in function delete_FieldValueVector> delete_FieldValueVector(FieldValueVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class FieldVector(__builtin__.object)     Proxy of C++ std::vector<(sb::Field)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> FieldVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> FieldVector __init__(self, *args) __init__(self) -> FieldVector __init__(self, FieldVector arg0) -> FieldVector __init__(self, size_type size) -> FieldVector __init__(self, size_type size, value_type value) -> FieldVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, FieldVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, FieldVector v = std::vector< sb::Field,std::allocator< sb::Field > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, FieldVector v) 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: __swig_destroy__ = <built-in function delete_FieldVector> delete_FieldVector(FieldVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Function(__builtin__.object)     Proxy of C++ sb::Function class     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self, string name, string functionDefinition, string body,      Tuple environment, CompleteDataType type) -> Function __init__(self, string name, string functionDefinition, CompleteDataType type) -> Function __init__(self, Function f) -> Function __init__(self, Function f, string inFT, string outFT, CompleteDataType type) -> Function __repr__ = _swig_repr(self) __setattr__ lambda self, name, value compare(self, *args) compare(self, Function f) -> int getBody(self) getBody(self) -> string   Returns the body of the function. getEnvironment(self) getEnvironment(self) -> Tuple   Returns a Tuple representing the environment against which the function body is evaluated. getFunctionDefinition(self) getFunctionDefinition(self) -> string getInFieldTransformer(self) getInFieldTransformer(self) -> string getInnerType(self) getInnerType(self) -> CompleteDataType getName(self) getName(self) -> string   Returns the name of the function. getOutFieldTransformer(self) getOutFieldTransformer(self) -> string getType(self) getType(self) -> CompleteDataType isCoerced(self) isCoerced(self) -> bool 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: __swig_destroy__ = <built-in function delete_Function> delete_Function(Function self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class IntVector(__builtin__.object)     Proxy of C++ std::vector<(int)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> IntVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> IntVector __init__(self, *args) __init__(self) -> IntVector __init__(self, IntVector arg0) -> IntVector __init__(self, size_type size) -> IntVector __init__(self, size_type size, value_type value) -> IntVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, IntVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, IntVector v = std::vector< int,std::allocator< int > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, IntVector v) 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: __swig_destroy__ = <built-in function delete_IntVector> delete_IntVector(IntVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class ListVector(__builtin__.object)     Proxy of C++ std::vector<(std::vector<(sb::FieldValue)>)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> ListVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> ListVector __init__(self, *args) __init__(self) -> ListVector __init__(self, ListVector arg0) -> ListVector __init__(self, size_type size) -> ListVector __init__(self, size_type size, value_type value) -> ListVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, ListVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, ListVector v = std::vector< std::vector< sb::FieldValue,std::allocator< sb::FieldValue > >,std::allocator< std::vector< sb::FieldValue,std::allocator< sb::FieldValue > > > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, ListVector v) 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: __swig_destroy__ = <built-in function delete_ListVector> delete_ListVector(ListVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class LongVector(__builtin__.object)     Proxy of C++ std::vector<(long long)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> LongVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> LongVector __init__(self, *args) __init__(self) -> LongVector __init__(self, LongVector arg0) -> LongVector __init__(self, size_type size) -> LongVector __init__(self, size_type size, value_type value) -> LongVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, LongVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, LongVector v = std::vector< long long,std::allocator< long long > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, LongVector v) 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: __swig_destroy__ = <built-in function delete_LongVector> delete_LongVector(LongVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Schema(__builtin__.object)     A type of tuple, containing zero or more fields (each encapsulated as a Schema::Field object).     Schemas are immutable: once constructed they may not be changed.     C++ includes: Schema.hpp     Methods defined here: __del__ lambda self __eq__(self, *args) x.__eq__(y) <==> x==y __getattr__ lambda self, name __getitem__(self, y) S.__getitem__(i) <==> S[i]   -> the ith Field of Schema S __init__(self, *args) __init__(self) -> Schema __init__(self, Schema schema) -> Schema __init__(self, string name, std::vector<(sb::Schema::Field,std::allocator<(sb::Schema::Field)>)> fields,      Flags flags = sb::Schema::Flags()) -> Schema __init__(self, string name, std::vector<(sb::Schema::Field,std::allocator<(sb::Schema::Field)>)> fields) -> Schema __init__(self, std::vector<(sb::Schema::Field,std::allocator<(sb::Schema::Field)>)> fields,      Flags flags = sb::Schema::Flags()) -> Schema __init__(self, std::vector<(sb::Schema::Field,std::allocator<(sb::Schema::Field)>)> fields) -> Schema   sb::Schema::Schema Constructs a Schema from a vector of Field objects.     If the vector is empty the Schema will contain no fields. __iter__(self) S.__iter__() <==> iter(S)    -> iterator over the Fields of Schema S __len__(self) S.__len__() <==> len(S)      -> the number of Fields in Schema S __ne__(self, *args) x.__ne__(y) <==> x!=y __nonzero__(self) x.__nonzero__() <==> x != 0 __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self) x.__str__() <==> str(x)   sb::Schema::as_string Returns a string representation of the schema. as_xml(self, *args) as_xml(self, string name = std::string(), bool aAddUUID = True) -> string as_xml(self, string name = std::string()) -> string as_xml(self) -> string copy(self) S.copy() -> a (really) shallow copy of S getField(self, *args) getField(self, size_t field_num) -> Field getField(self, string pathName) -> Field   sb::Schema::getField Return the Fields object description of a field in the schema.     Parameters ---------- * `pathName` :       the path name of the field to fetch.     Exceptions ---------- * `NoSuchFieldException` :       if field is not found. getFields(self) getFields(self) -> std::vector<(sb::Schema::Field,std::allocator<(sb::Schema::Field)>)>   sb::Schema::getFields Returns a reference to a vector of all fields in the schema. getHeaderSize(self) getHeaderSize(self) -> size_t   sb::Schema::getHeaderSize Return the size of the header. getName(self) getName(self) -> string   sb::Schema::getName Returns the name of the schema or empty string at runtime. getNullMaskOffset(self) getNullMaskOffset(self) -> size_t getNullMaskSize(self) getNullMaskSize(self) -> size_t getNumFields(self) getNumFields(self) -> size_t   sb::Schema::getNumFields Returns the number of fields in the schema. hasField(self, *args) hasField(self, string pathName) -> bool   sb::Schema::hasField Returns true if a field of a given path name is present, otherwise it returns false.     Parameters ---------- * `pathName` :       the path name of the field to fetch. hasHeader(self) hasHeader(self) -> bool   sb::Schema::hasHeader Return true if the schema has space for a header, false otherwise.     Deprecated indexOfField(self, *args) indexOfField(self, string name) -> int   sb::Schema::indexOfField Returns the index of the field with a particular name (note: **not** path name), or -1 if there is no such field. sameFieldTypes(self, *args) sameFieldTypes(self, Schema other) -> bool   sb::Schema::sameFieldTypes Returns true if this schema has the same field types in the same order as another Schema. sameFields(self, *args) sameFields(self, Schema other) -> bool   sb::Schema::sameFields Returns true if this schema has the same field Names and Types in the same order as another Schema. Static methods defined here: fromXml(*args) fromXml(string input, Flags flags = sb::Schema::Flags()) -> Schema fromXml(string input) -> Schema   sb::Schema::fromXml Parse and return a schema from an XML string.     The root tag must be <schema>. 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: EMPTY_SCHEMA = <streambase.Schema; proxy of <Swig Object of type 'sb::Schema *' at 0x7f50c5e95390> > NO_HEADER = 1 __swig_destroy__ = <built-in function delete_Schema> delete_Schema(Schema self)   sb::Schema::~Schema __swig_getmethods__ = {'fromXml': <function <lambda>>} __swig_setmethods__ = {}   class SchemaRep(__builtin__.object)     Proxy of C++ sb::SchemaRep class     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args, **kwargs) __repr__ = _swig_repr(self) __setattr__ lambda self, name, value 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: __swig_destroy__ = <built-in function delete_SchemaRep> delete_SchemaRep(SchemaRep self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class StreamBaseException(exceptions.Exception)     The base class for all StreamBaseExceptions.     Currently defined exceptions include     *   StreamBaseNoSuchEntityException: requested an entity which doesn't exist   *   StreamBaseBadXmlException: non-well-formed (i.e., unparseable) XML   *   StreamBaseBadEntityException: semantically invalid entity description (e.g.,     box doesn't have a type)   *   StreamBaseTypingException: typechecking failed   *   StreamBaseIllegalArgumentException: miscellaneous illegal argument provided     An StreamBaseException should never be thrown directly; use the Throw macro instead.     C++ includes: Exceptions.hpp     Method resolution order: StreamBaseException exceptions.Exception exceptions.BaseException __builtin__.object Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self, string code, string message, Type error_type = UNKNOWNTYPE,      string type = "StreamBaseException") -> StreamBaseException __init__(self, string code, string message, Type error_type = UNKNOWNTYPE) -> StreamBaseException __init__(self, string code, string message) -> StreamBaseException __init__(self, string code, string message, StreamBaseException c,      Type error_type = UNKNOWNTYPE, string type = "StreamBaseException") -> StreamBaseException __init__(self, string code, string message, StreamBaseException c,      Type error_type = UNKNOWNTYPE) -> StreamBaseException __init__(self, string code, string message, StreamBaseException c) -> StreamBaseException   sb::StreamBaseException::StreamBaseException Constructor.          Parameters ---------- * `code` :       see ExceptionsCodes.hpp; use SB_NEW_MESSAGE_CODE if in doubt   * `message` :       the exception message   * `c` :       an exception that is the "cause" of this exception   * `error_type` :       the class of error, for server runtime error handling   * `type` :       the type of the exception __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self) x.__str__() <==> str(x) asXmlString(self) asXmlString(self) -> string asXmlStringSingle(self) asXmlStringSingle(self) -> string boxname(self, *args) boxname(self, string name) -> StreamBaseException boxparam(self, *args) boxparam(self, string name) -> StreamBaseException cause(self, *args) cause(self, StreamBaseException val) -> StreamBaseException chainAsString(self) chainAsString(self) -> string code(self, *args) code(self, string val) -> StreamBaseException code(self, int val) -> StreamBaseException fieldname(self, *args) fieldname(self, string name) -> StreamBaseException file(self, *args) file(self, char val) -> StreamBaseException file(self, string val) -> StreamBaseException findByType(self, *args) findByType(self, string type) -> StreamBaseException function(self, *args) function(self, char val) -> StreamBaseException function(self, string val) -> StreamBaseException getBoxName(self) getBoxName(self) -> string getBoxParam(self) getBoxParam(self) -> string getCause(self) getCause(self) -> StreamBaseException getChainOfMessages(self) getChainOfMessages(self) -> string getCode(self) getCode(self) -> string getDeepest(self) getDeepest(self) -> StreamBaseException getErrorType(self) getErrorType(self) -> Type getFieldName(self) getFieldName(self) -> string getFile(self) getFile(self) -> string getFunction(self) getFunction(self) -> string getLine(self) getLine(self) -> unsigned int getMessage(self) getMessage(self) -> string getParam(self, *args) getParam(self, string name) -> string getStackTrace(self) getStackTrace(self) -> string getSummary(self) getSummary(self) -> string getType(self) getType(self) -> string hasCause(self) hasCause(self) -> bool line(self, *args) line(self, int val) -> StreamBaseException linkAsString(self) linkAsString(self) -> string message(self, *args) message(self, string val) -> StreamBaseException param(self, *args) param(self, string name, string val) -> StreamBaseException param(self, string name, int val) -> StreamBaseException summary(self, *args) summary(self, string val) -> StreamBaseException throwMyself(self) throwMyself(self) type(self, *args) type(self, string val) -> StreamBaseException what(self) what(self) -> char   sb::StreamBaseException::what Returns the message as a C string.     The string is owned by this object, so the pointer becomes invalid upon destruction of the StreamBaseException. Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __swig_destroy__ = <built-in function delete_StreamBaseException> delete_StreamBaseException(StreamBaseException self)   sb::StreamBaseException::~StreamBaseException Destructor. __swig_getmethods__ = {'fromXmlString': <function <lambda>>} __swig_setmethods__ = {} 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__(...) __setstate__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args   class StreamBaseXmlRpcFault(StreamBaseException)     An XML/RPC error has occurred.     C++ includes: Exceptions.hpp     Method resolution order: StreamBaseXmlRpcFault StreamBaseException exceptions.Exception exceptions.BaseException __builtin__.object Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) __init__(self, int fault_code, string fault_string) -> StreamBaseXmlRpcFault __init__(self, string code, string message, Type error_type = UNKNOWNTYPE,      string type = "StreamBaseXmlRpcFault") -> StreamBaseXmlRpcFault __init__(self, string code, string message, Type error_type = UNKNOWNTYPE) -> StreamBaseXmlRpcFault __init__(self, string code, string message) -> StreamBaseXmlRpcFault __init__(self, string code, string message, StreamBaseException c,      Type error_type = UNKNOWNTYPE, string type = "StreamBaseXmlRpcFault") -> StreamBaseXmlRpcFault __init__(self, string code, string message, StreamBaseException c,      Type error_type = UNKNOWNTYPE) -> StreamBaseXmlRpcFault __init__(self, string code, string message, StreamBaseException c) -> StreamBaseXmlRpcFault   sb::StreamBaseXmlRpcFault::StreamBaseXmlRpcFault __repr__ = _swig_repr(self) __setattr__ lambda self, name, value throwMyself(self) throwMyself(self) Data and other attributes defined here: __swig_destroy__ = <built-in function delete_StreamBaseXmlRpcFault> delete_StreamBaseXmlRpcFault(StreamBaseXmlRpcFault self) __swig_getmethods__ = {'fromXmlString': <function <lambda>>} __swig_setmethods__ = {} Methods inherited from StreamBaseException: __str__(self) x.__str__() <==> str(x) asXmlString(self) asXmlString(self) -> string asXmlStringSingle(self) asXmlStringSingle(self) -> string boxname(self, *args) boxname(self, string name) -> StreamBaseException boxparam(self, *args) boxparam(self, string name) -> StreamBaseException cause(self, *args) cause(self, StreamBaseException val) -> StreamBaseException chainAsString(self) chainAsString(self) -> string code(self, *args) code(self, string val) -> StreamBaseException code(self, int val) -> StreamBaseException fieldname(self, *args) fieldname(self, string name) -> StreamBaseException file(self, *args) file(self, char val) -> StreamBaseException file(self, string val) -> StreamBaseException findByType(self, *args) findByType(self, string type) -> StreamBaseException function(self, *args) function(self, char val) -> StreamBaseException function(self, string val) -> StreamBaseException getBoxName(self) getBoxName(self) -> string getBoxParam(self) getBoxParam(self) -> string getCause(self) getCause(self) -> StreamBaseException getChainOfMessages(self) getChainOfMessages(self) -> string getCode(self) getCode(self) -> string getDeepest(self) getDeepest(self) -> StreamBaseException getErrorType(self) getErrorType(self) -> Type getFieldName(self) getFieldName(self) -> string getFile(self) getFile(self) -> string getFunction(self) getFunction(self) -> string getLine(self) getLine(self) -> unsigned int getMessage(self) getMessage(self) -> string getParam(self, *args) getParam(self, string name) -> string getStackTrace(self) getStackTrace(self) -> string getSummary(self) getSummary(self) -> string getType(self) getType(self) -> string hasCause(self) hasCause(self) -> bool line(self, *args) line(self, int val) -> StreamBaseException linkAsString(self) linkAsString(self) -> string message(self, *args) message(self, string val) -> StreamBaseException param(self, *args) param(self, string name, string val) -> StreamBaseException param(self, string name, int val) -> StreamBaseException summary(self, *args) summary(self, string val) -> StreamBaseException type(self, *args) type(self, string val) -> StreamBaseException what(self) what(self) -> char   sb::StreamBaseException::what Returns the message as a C string.     The string is owned by this object, so the pointer becomes invalid upon destruction of the StreamBaseException. Data descriptors inherited from StreamBaseException: __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__(...) __setstate__(...) __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args   class StreamProperties(__builtin__.object)     Properties of a single stream.     Returned by StreamBaseClient::getStreamProperties().     C++ includes: StreamProperties.hpp     Methods defined here: __del__ lambda self __eq__(self, *args) x.__eq__(y) <==> x==y __getattr__ lambda self, name __init__(self) __init__(self) -> StreamProperties   sb::StreamProperties::StreamProperties Null constructor. Object will have no name and no schema. __lt__(self, *args) x.__lt__(y) <==> x<y __ne__(self, *args) x.__ne__(y) <==> x!=y __repr__ = _swig_repr(self) __setattr__ lambda self, name, value getCaptureTransformStrategy(self) getCaptureTransformStrategy(self) -> CaptureTransformStrategy   sb::StreamProperties::getCaptureTransformStrategy getContainerName(self) getContainerName(self) -> string   sb::StreamProperties::getContainerName Returns the container part of the stream. getName(self) getName(self) -> string   sb::StreamProperties::getName Returns the name part of the stream. getQualifiedName(self) getQualifiedName(self) -> string   sb::StreamProperties::getQualifiedName Returns the fully qualified name of the stream. getSchema(self) getSchema(self) -> Schema   Returns the schema of the stream. hashString(self) hashString(self) -> string   sb::StreamProperties::hashString Returns the hash of the stream in binary. hashValue(self) hashValue(self) -> size_t   sb::StreamProperties::hashValue hexString(self) hexString(self) -> string   sb::StreamProperties::hexString Static methods defined here: fromXml(*args) fromXml(string input) -> StreamProperties   sb::StreamProperties::fromXml Parse and return a StreamProperties from an XML String.     The root tag must be <stream>. 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: FLATTEN = 0 NEST = 1 RAW = 2 __swig_destroy__ = <built-in function delete_StreamProperties> delete_StreamProperties(StreamProperties self) __swig_getmethods__ = {'fromXml': <function <lambda>>} __swig_setmethods__ = {}   class StringHashFunc(__builtin__.object)     Proxy of C++ sb::StringHashFunc class     Methods defined here: __call__(self, *args) __call__(self, string str) -> size_t __del__ lambda self __getattr__ lambda self, name __init__(self) __init__(self) -> StringHashFunc __repr__ = _swig_repr(self) __setattr__ lambda self, name, value 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: __swig_destroy__ = <built-in function delete_StringHashFunc> delete_StringHashFunc(StringHashFunc self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class StringVector(__builtin__.object)     Proxy of C++ std::vector<(std::string)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> StringVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> StringVector __init__(self, *args) __init__(self) -> StringVector __init__(self, StringVector arg0) -> StringVector __init__(self, size_type size) -> StringVector __init__(self, size_type size, value_type value) -> StringVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, StringVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, StringVector v = std::vector< std::string,std::allocator< std::string > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, StringVector v) 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: __swig_destroy__ = <built-in function delete_StringVector> delete_StringVector(StringVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class SwigPyIterator(__builtin__.object)     Proxy of C++ swig::SwigPyIterator class     Methods defined here: __add__(self, *args) __add__(self, ptrdiff_t n) -> SwigPyIterator __del__ lambda self __eq__(self, *args) __eq__(self, SwigPyIterator x) -> bool __getattr__ lambda self, name __iadd__(self, *args) __iadd__(self, ptrdiff_t n) -> SwigPyIterator __init__(self, *args, **kwargs) __isub__(self, *args) __isub__(self, ptrdiff_t n) -> SwigPyIterator __iter__(self) __ne__(self, *args) __ne__(self, SwigPyIterator x) -> bool __next__(self) __next__(self) -> PyObject __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __sub__(self, *args) __sub__(self, ptrdiff_t n) -> SwigPyIterator __sub__(self, SwigPyIterator x) -> ptrdiff_t advance(self, *args) advance(self, ptrdiff_t n) -> SwigPyIterator copy(self) copy(self) -> SwigPyIterator decr(self, n=1) decr(self, size_t n = 1) -> SwigPyIterator decr(self) -> SwigPyIterator distance(self, *args) distance(self, SwigPyIterator x) -> ptrdiff_t equal(self, *args) equal(self, SwigPyIterator x) -> bool incr(self, n=1) incr(self, size_t n = 1) -> SwigPyIterator incr(self) -> SwigPyIterator next(self) next(self) -> PyObject previous(self) previous(self) -> PyObject value(self) value(self) -> PyObject 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: __swig_destroy__ = <built-in function delete_SwigPyIterator> delete_SwigPyIterator(SwigPyIterator self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Timestamp(__builtin__.object)     Class for representing moments in time and intervals at millisecond granularity.     C++ includes: Timestamp.hpp     Methods defined here: __add__(self, *args) __add__(self, Timestamp rhs) -> Timestamp __del__ lambda self __div__(self, *args) __div__(self, Timestamp rhs) -> double __eq__(self, *args) x.__eq__(y) <==> x==y __ge__(self, *args) x.__ge__(y) <==> x>=y __getattr__ lambda self, name __gt__(self, *args) x.__gt__(y) <==> x>y __iadd__(self, *args) __iadd__(self, Timestamp rhs) -> Timestamp __imod__(self, *args) __imod__(self, Timestamp rhs) -> Timestamp __init__(self) __init__(self) -> Timestamp   sb::Timestamp::Timestamp Create a default Timestamp.     Will initialized to 00:00:00 1 Jan 1970. __isub__(self, *args) __isub__(self, Timestamp rhs) -> Timestamp __le__(self, *args) x.__le__(y) <==> x<=y __lt__(self, *args) x.__lt__(y) <==> x<y __mod__(self, *args) __mod__(self, Timestamp rhs) -> Timestamp __ne__(self, *args) x.__ne__(y) <==> x!=y __neg__(self) __neg__(self) -> Timestamp __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self, displayTimezone=True) x.__str__() <==> str(x) x.__str__() <==> str(x)   sb::Timestamp::as_string Return a human readable string rep of this Timestamp. __sub__(self, *args) __sub__(self, Timestamp rhs) -> Timestamp compare(self, *args) compare(self, Timestamp other) -> int   sb::Timestamp::compare compare 2 timestamps return less than zero this < other return greater than zero this > other return 0 if they are the same getDayOfMonth(self) getDayOfMonth(self) -> int   sb::Timestamp::getDayOfMonth Return day of month. getDayOfWeek(self) getDayOfWeek(self) -> int   sb::Timestamp::getDayOfWeek Return day since Sunday. getHour(self) getHour(self) -> int   sb::Timestamp::getHour Return hours since midnight. getMillisecond(self) getMillisecond(self) -> double   sb::Timestamp::getMillisecond Return milliseconds after the second. getMinute(self) getMinute(self) -> int   sb::Timestamp::getMinute Return minutes after hour. getMonth(self) getMonth(self) -> int   sb::Timestamp::getMonth Return month since January. getSecond(self) getSecond(self) -> double   sb::Timestamp::getSecond Return seconds after the minute. getYear(self) getYear(self) -> int   sb::Timestamp::getYear Return year. isInterval(self) isInterval(self) -> bool   sb::Timestamp::isInterval Return true if this Timestamp is an interval. setDayOfMonth(self, *args) setDayOfMonth(self, int day_of_month)   sb::Timestamp::setDayOfMonth Set day of month. setHour(self, *args) setHour(self, int hours)   sb::Timestamp::setHour Set hours since midnight. setMinute(self, *args) setMinute(self, int minutes)   sb::Timestamp::setMinute Set minutes after the hour. setMonth(self, *args) setMonth(self, int month)   sb::Timestamp::setMonth Set month since January. setSecond(self, *args) setSecond(self, double seconds)   sb::Timestamp::setSecond Set seconds after the minute. setYear(self, *args) setYear(self, int year)   sb::Timestamp::setYear Set year. toMsecs(self) toMsecs(self) -> long long   sb::Timestamp::toMsecs Return the time as milliseconds. toSecs(self) toSecs(self) -> long long   sb::Timestamp::toSecs Return the time as seconds. Static methods defined here: days(*args) days(double days) -> Timestamp   sb::Timestamp::days Construct an interval from days. hours(*args) hours(double hours) -> Timestamp   sb::Timestamp::hours Construct an interval from hours. milliseconds(*args) milliseconds(long long milliseconds) -> Timestamp   sb::Timestamp::milliseconds Create a time from a count of milliseconds. minutes(*args) minutes(double minutes) -> Timestamp   sb::Timestamp::minutes Construct an interval from minutes. now() now() -> Timestamp   sb::Timestamp::now Return a Timestamp representing the current moment in time. seconds(*args) seconds(double seconds) -> Timestamp   sb::Timestamp::seconds Create a time from a count of seconds. weeks(*args) weeks(double weeks) -> Timestamp   sb::Timestamp::weeks Construct an interval from weeks. 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: MAX_DAY = 31 MAX_HOUR = 23 MAX_MINUTE = 59 MAX_MONTH = 12 MAX_SECOND = 59 MAX_YEAR = 9999 MIN_DAY = 1 MIN_HOUR = 0 MIN_MINUTE = 0 MIN_MONTH = 1 MIN_SECOND = 0 MIN_YEAR = 1400 __swig_destroy__ = <built-in function delete_Timestamp> delete_Timestamp(Timestamp self) __swig_getmethods__ = {'days': <function <lambda>>, 'hours': <function <lambda>>, 'milliseconds': <function <lambda>>, 'minutes': <function <lambda>>, 'now': <function <lambda>>, 'seconds': <function <lambda>>, 'weeks': <function <lambda>>} __swig_setmethods__ = {}   class TimestampVector(__builtin__.object)     Proxy of C++ std::vector<(sb::Timestamp)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> TimestampVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> TimestampVector __init__(self, *args) __init__(self) -> TimestampVector __init__(self, TimestampVector arg0) -> TimestampVector __init__(self, size_type size) -> TimestampVector __init__(self, size_type size, value_type value) -> TimestampVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, TimestampVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, TimestampVector v = std::vector< sb::Timestamp,std::allocator< sb::Timestamp > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, TimestampVector v) 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: __swig_destroy__ = <built-in function delete_TimestampVector> delete_TimestampVector(TimestampVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Tuple(__builtin__.object)     Tuples are value types that can be copied and modified separately thus.     t2 = t1;    t2.setId(0); // does not modify t1     They will only make copies of the underlying data as needed, so they are relatively cheap to pass around by value     C++ includes: Tuple.hpp     Methods defined here: __del__ lambda self __eq__(self, *args) x.__eq__(y) <==> x==y   If y is a Python tuple, before comparison it will be converted to a Tuple with x's Schema. __getattr__ lambda self, name __getitem__(self, *args) x.__getitem__(y) <==> x[y] y can be a Field object, a field name as a string, or an index as an integer __init__(self, *args) __init__(self) -> Tuple __init__(self, Tuple t) -> Tuple __init__(self, Schema s) -> Tuple   sb::Tuple::Tuple Construct a tuple of the specified schema. __iter__(self) x.__iter__() <==> iter(x) __len__(self) x.__len__() <==> len(x) __ne__(self, other) x.__ne__(y) <==> x!=y __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) x.__setitem__(i, y) <==> x[y]=i y can be a Field object, a field name as a string, or an index as an integer __str__(self) x.__str__() <==> str(x)   sb::Tuple::as_string Return a human-readable string value representing this tuple in its entirety (including all header values, if applicable).     Returns ------- the string value. as_string_external(self, *args) as_string_external(self, char delimiter = ',', string null_string = getNullString()) -> string as_string_external(self, char delimiter = ',') -> string as_string_external(self) -> string   sb::Tuple::as_string_external Return a human-readable string value representing this tuple.     It compares to as_string by allowing a user-specified delimiter between fields, making the header timestamp stand out, and omitting the TupleId header field. null_string is written out for any null field.     Returns ------- the string value clear(self) clear(self)   sb::Tuple::clear null all fields in the tuple copy(self) T.copy() -> a (really) shallow copy of T copyIntoBuffer(self, *args) copyIntoBuffer(self, void buf, size_t len, bool byteswap) -> size_t get(self, k, d=None) T.get(k[,d]) -> T[k] if k in T, else d.  d defaults to None. getBlobBuffer(self, *args) getBlobBuffer(self, Field f) -> string getBlobBuffer(self, size_t i) -> string getBlobBuffer(self, string n) -> string   sb::Tuple::getBlobBuffer getBool(self, *args) getBool(self, Field f) -> bool getBool(self, size_t i) -> bool getBool(self, string n) -> bool   sb::Tuple::getBool getDouble(self, *args) getDouble(self, Field f) -> double getDouble(self, size_t i) -> double getDouble(self, string n) -> double   sb::Tuple::getDouble getFieldValue(self, *args) getFieldValue(self, Field f) -> FieldValue getFieldValue(self, Field f) -> FieldValue getFieldValue(self, size_t field_num) -> FieldValue getFieldValue(self, size_t field_num) -> FieldValue getFieldValue(self, string field_name) -> FieldValue getFieldValue(self, string field_name) -> FieldValue   sb::Tuple::getFieldValue Takes the name of a field in this tuple's schema, returns the corresponding field value. getFunction(self, *args) getFunction(self, Field f) -> Function getFunction(self, size_t i) -> Function getFunction(self, string n) -> Function   sb::Tuple::getFunction getId(self) getId(self) -> unsigned int   sb::Tuple::getId Returns ------- The id for this tuple getInt(self, *args) getInt(self, Field f) -> int getInt(self, size_t i) -> int getInt(self, string n) -> int   sb::Tuple::getInt getList(self, *args) getList(self, Field f) -> FieldValueVector getList(self, size_t i) -> FieldValueVector getList(self, string n) -> FieldValueVector   sb::Tuple::getList getLong(self, *args) getLong(self, Field f) -> long long getLong(self, size_t i) -> long long getLong(self, string n) -> long long   sb::Tuple::getLong getNumFields(self) getNumFields(self) -> size_t   sb::Tuple::getNumFields Returns ------- the number of fields in the tuple's schema getSchema(self) getSchema(self) -> Schema   Returns the schema of the stream. getSize(self) getSize(self) -> size_t   sb::Tuple::getSize Returns ------- the serialized size of this tuple getString(self, *args) getString(self, Field f) -> string getString(self, size_t i) -> string getString(self, string n) -> string   sb::Tuple::getString getTimestamp(self, *args) getTimestamp(self, Field f) -> Timestamp getTimestamp(self, size_t i) -> Timestamp getTimestamp(self, string n) -> Timestamp   sb::Tuple::getTimestamp getTuple(self, *args) getTuple(self, Field f) -> Tuple getTuple(self, size_t i) -> Tuple getTuple(self, string n) -> Tuple   sb::Tuple::getTuple hasHeader(self) hasHeader(self) -> bool   sb::Tuple::hasHeader Returns ------- true if tuple has a header, false otherwise has_key(self, k) T.has_key(k) -> True if T has a field named k, else False isNull(self, *args) isNull(self, Field f) -> bool isNull(self, size_t i) -> bool isNull(self, string n) -> bool   sb::Tuple::isNull items(self) T.items() -> list of T's (field name, field value) pairs,  as 2-tuples iteritems(self) T.iteritems() -> an iterator over the (field name, field value)  items of T iterkeys(self) T.iterkeys() -> an iterator over the field names of T itervalues(self) T.itervalues() -> an iterator over the field values of T keys(self) T.keys() -> list of T's field names setBlobBuffer(self, *args) setBlobBuffer(self, Field f, string v) setBlobBuffer(self, size_t i, string v) setBlobBuffer(self, string n, string v)   sb::Tuple::setBlobBuffer setBool(self, *args) setBool(self, Field f, bool v) setBool(self, size_t i, bool v) setBool(self, string n, bool v)   sb::Tuple::setBool setDouble(self, *args) setDouble(self, Field f, double v) setDouble(self, size_t i, double v) setDouble(self, string n, double v)   sb::Tuple::setDouble setFieldValue(self, *args) setFieldValue(self, Field f, FieldValue fv) setFieldValue(self, size_t field_num, FieldValue fv) setFieldValue(self, string field_name, FieldValue fv)   sb::Tuple::setFieldValue Takes the name of a field in this tuple's schema and sets the corresponding field value. setFromPackedBuffer(self, *args) setFromPackedBuffer(self, void buf, size_t buf_len, bool byteswap, Schema s) -> size_t setFunction(self, *args) setFunction(self, Field f, Function v) setFunction(self, size_t i, Function v) setFunction(self, string n, Function v)   sb::Tuple::setFunction setId(self, *args) setId(self, unsigned int tid)   sb::Tuple::setId set the id setInt(self, *args) setInt(self, Field f, int v) setInt(self, size_t i, int v) setInt(self, string n, int v)   sb::Tuple::setInt setList(self, *args) setList(self, Field f, FieldValueVector v) setList(self, size_t i, FieldValueVector v) setList(self, string n, FieldValueVector v)   sb::Tuple::setList setLong(self, *args) setLong(self, Field f, long long v) setLong(self, size_t i, long long v) setLong(self, string n, long long v)   sb::Tuple::setLong setNull(self, *args) setNull(self, Field f) setNull(self, size_t i) setNull(self, string n)   sb::Tuple::setNull setSchema(self, *args) setSchema(self, Schema arg0)   sb::Tuple::setSchema set the schema setString(self, *args) setString(self, Field field, string value, Flags flags = NONE) setString(self, Field field, string value) setString(self, size_t field, char data, size_t len, Flags flags = NONE) setString(self, size_t field, char data, size_t len) setString(self, string field, char data, size_t len, Flags flags = NONE) setString(self, string field, char data, size_t len) setString(self, Field field, char data, size_t len, Flags flags = NONE) setString(self, Field field, char data, size_t len) setString(self, size_t field_index, string value, Flags flags = NONE) setString(self, size_t field_index, string value) setString(self, string field_name, string value, Flags flags = NONE) setString(self, string field_name, string value)   sb::Tuple::setString setTimestamp(self, *args) setTimestamp(self, Field f, Timestamp v) setTimestamp(self, size_t i, Timestamp v) setTimestamp(self, string n, Timestamp v)   sb::Tuple::setTimestamp setTuple(self, *args) setTuple(self, Field f, Tuple v) setTuple(self, size_t i, Tuple v) setTuple(self, string n, Tuple v)   sb::Tuple::setTuple setdefault(self, k, d=None) T.setdefault(k[,d]) -> T.get(k,d), also set T[k]=d if k  not in T toDelimitedString(self, *args) toDelimitedString(self, string delimiter, string null_string = getNullString(),      bool include_names = False, bool quote_all_strings = False) -> string toDelimitedString(self, string delimiter, string null_string = getNullString(),      bool include_names = False) -> string toDelimitedString(self, string delimiter, string null_string = getNullString()) -> string toDelimitedString(self, string delimiter) -> string   sb::Tuple::toDelimitedString Return a string value representing this tuple, separated by the given delimiter.     Parameters ---------- * `delimiter` :       the string to put between fields   * `null_string` :       the string used to represent null values   * `include_names` :       whether to preface each field with "<name>="   * `quote_all_strings` :       whether to put quotes around all strings, regardless of need     Returns ------- the result string values(self) T.values() -> list of T's field values verify(self) verify(self)   sb::Tuple::verify verify that the tuple is valid Throws StreamBaseException on invalid tuple writeCSVString(self, *args) writeCSVString(self, std::ostream out, char delim, char quote, string null_string = getNullString()) writeCSVString(self, std::ostream out, char delim, char quote) Static methods defined here: createFromPackedBuffer(*args) createFromPackedBuffer(size_t size_used, void buf, size_t buf_len, bool byteswap,      Schema s) -> Tuple getNullString() getNullString() -> string   sb::Tuple::getNullString Return the default string used to represent null, i.e., null. 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: NONE = 0 TRUNCATE = 1 __swig_destroy__ = <built-in function delete_Tuple> delete_Tuple(Tuple self)   sb::Tuple::~Tuple Destructor. __swig_getmethods__ = {'createFromPackedBuffer': <function <lambda>>, 'getNullString': <function <lambda>>} __swig_setmethods__ = {}   class TupleList(__builtin__.object)     TupleLists are value types that can be copied and modified seperately thus.     tl2 = tl1; tl2[0].clear(); // does not modify t1     They will only make copies of the underlying data as needed, so they are relatively cheap to pass around by value     C++ includes: TupleList.hpp     Methods defined here: __del__ lambda self __getattr__ lambda self, name __getitem__(self, *args) x.__getitem__(y) <==> x[y] __init__(self, *args) __init__(self) -> TupleList __init__(self, Tuple tuple) -> TupleList __init__(self, TupleList list) -> TupleList __init__(self, Schema schema, size_t size = 0) -> TupleList __init__(self, Schema schema) -> TupleList   sb::TupleList::TupleList Create tuple list with an initial size of *size* __iter__(self) x.__iter__() <==> iter(x) __len__(self) x.__len__() <==> len(x) __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) x.__setitem__(y, i) <==> x[y]=i __str__(self) x.__str__() <==> str(x)   sb::TupleList::as_string Return a human-readable string value representing this list in its entirety (including all header values, if applicable).     Returns ------- the string value. back(self, *args) back(self) -> Tuple back(self) -> Tuple   sb::TupleList::back begin(self, *args) begin(self) -> iterator begin(self) -> const_iterator   sb::TupleList::begin clear(self) clear(self)   sb::TupleList::clear clear the list copyIntoBuffer(self, *args) copyIntoBuffer(self, char buf, size_t len, bool byteswap) -> size_t empty(self) empty(self) -> bool   sb::TupleList::empty Is the list empty? end(self, *args) end(self) -> iterator end(self) -> const_iterator   sb::TupleList::end getRawBits(self) getRawBits(self) -> string getSchema(self) getSchema(self) -> Schema   sb::TupleList::getSchema Get the schema. getSize(self) getSize(self) -> size_t   sb::TupleList::getSize Get the number of tuples in the list. push_back(self, *args) push_back(self, Tuple r)   sb::TupleList::push_back append a tuple to the list resize(self, *args) resize(self, size_t size)   sb::TupleList::resize Change the size of the list any new tuples will be entirely null. setRawBits(self, *args) setRawBits(self, char bits, size_t len) setSchema(self, *args) setSchema(self, Schema schema)   sb::TupleList::setSchema set the schema for this list (also setting the schema for any tuples in the list) setSize(self, *args) setSize(self, size_t size)   sb::TupleList::setSize size(self) size(self) -> size_t   sb::TupleList::size Static methods defined here: createFromPackedBuffer(*args) createFromPackedBuffer(size_t size_used, char buf, size_t buf_len, bool byteswap,      Schema s, size_t expect_num_tuples = (size_t) -1) -> TupleList createFromPackedBuffer(size_t size_used, char buf, size_t buf_len, bool byteswap,      Schema s) -> TupleList createRawFromPackedBuffer(*args) createRawFromPackedBuffer(size_t size_used, char buf, size_t buf_len, bool byteswap,      Schema s, size_t expect_num_tuples = (size_t) -1) -> TupleList createRawFromPackedBuffer(size_t size_used, char buf, size_t buf_len, bool byteswap,      Schema s) -> TupleList 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: __swig_destroy__ = <built-in function delete_TupleList> delete_TupleList(TupleList self)   sb::TupleList::~TupleList __swig_getmethods__ = {'createFromPackedBuffer': <function <lambda>>, 'createRawFromPackedBuffer': <function <lambda>>} __swig_setmethods__ = {}   class TuplePrivateImpl(__builtin__.object)     Proxy of C++ sb::TuplePrivateImpl class     Methods defined here: __del__ lambda self __eq__(self, *args) x.__eq__(y) <==> x==y __getattr__ lambda self, name __init__(self, *args) __init__(self) -> TuplePrivateImpl __init__(self, TuplePrivateImpl t) -> TuplePrivateImpl __repr__ = _swig_repr(self) __setattr__ lambda self, name, value get(self, *args) get(self, Field f) -> FieldValue get(self, Field f) -> FieldValue Static methods defined here: copyFieldValueIntoBuffer(*args) copyFieldValueIntoBuffer(char buf, size_t buf_len, Field f, FieldValue fv, bool byteswap) -> size_t extractBlob(*args) extractBlob(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractBool(*args) extractBool(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractDouble(*args) extractDouble(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractFunction(*args) extractFunction(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractInt(*args) extractInt(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractList(*args) extractList(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractLong(*args) extractLong(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractString(*args) extractString(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractTimestamp(*args) extractTimestamp(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractTuple(*args) extractTuple(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t extractVarLength(*args) extractVarLength(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t getBlobFromFieldValue(*args) getBlobFromFieldValue(Field f, FieldValue fv) -> string getBoolFromFieldValue(*args) getBoolFromFieldValue(Field f, FieldValue fv) -> bool getDoubleFromFieldValue(*args) getDoubleFromFieldValue(Field f, FieldValue fv) -> double getFunctionFromFieldValue(*args) getFunctionFromFieldValue(Field f, FieldValue fv) -> Function getIntFromFieldValue(*args) getIntFromFieldValue(Field f, FieldValue fv) -> int getListFromFieldValue(*args) getListFromFieldValue(Field f, FieldValue fv) -> FieldValueVector getLongFromFieldValue(*args) getLongFromFieldValue(Field f, FieldValue fv) -> long long getStringFromFieldValue(*args) getStringFromFieldValue(Field f, FieldValue fv) -> string getTimestampFromFieldValue(*args) getTimestampFromFieldValue(Field f, FieldValue fv) -> Timestamp getTimestampLongFromFieldValue(*args) getTimestampLongFromFieldValue(Field f, FieldValue fv) -> long long getTupleFromFieldValue(*args) getTupleFromFieldValue(Field f, FieldValue fv) -> Tuple getTupleMutableFromFieldValue(*args) getTupleMutableFromFieldValue(Field f, FieldValue fv) -> Tuple getVarLengthFromFieldValue(*args) getVarLengthFromFieldValue(CompleteDataType cdt, Field f, FieldValue fv) -> string injectBlob(*args) injectBlob(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectBool(*args) injectBool(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectDouble(*args) injectDouble(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectFunction(*args) injectFunction(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectInt(*args) injectInt(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectList(*args) injectList(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectLong(*args) injectLong(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectString(*args) injectString(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectTimestamp(*args) injectTimestamp(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectTuple(*args) injectTuple(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t injectVarLength(*args) injectVarLength(char buf, size_t size, Field field, FieldValue fv,      bool byteswap) -> size_t setBlobFieldValue(*args) setBlobFieldValue(string value, Field f, FieldValue fv) setBoolFieldValue(*args) setBoolFieldValue(bool value, Field f, FieldValue fv) setDoubleFieldValue(*args) setDoubleFieldValue(double value, Field f, FieldValue fv) setFieldValue(*args) setFieldValue(FieldValue value, Field f, FieldValue lhs) setFieldValueFromPackedBuffer(*args) setFieldValueFromPackedBuffer(char buf, size_t buf_len, Field f, FieldValue fv, bool byteswap) -> size_t setFunctionFieldValue(*args) setFunctionFieldValue(Function value, Field f, FieldValue fv) setIntFieldValue(*args) setIntFieldValue(int value, Field f, FieldValue fv) setListFieldValue(*args) setListFieldValue(FieldValueVector value, Field f, FieldValue fv) setLongFieldValue(*args) setLongFieldValue(long long value, Field f, FieldValue fv) setStringFieldValue(*args) setStringFieldValue(string value, Field f, FieldValue fv) setTimestampFieldValue(*args) setTimestampFieldValue(Timestamp value, Field f, FieldValue fv) setTimestampLongFieldValue(*args) setTimestampLongFieldValue(long long value, Field f, FieldValue fv) setTupleFieldValue(*args) setTupleFieldValue(Tuple value, Field f, FieldValue fv) setVarLengthFieldValue(*args) setVarLengthFieldValue(CompleteDataType cdt, string value, Field f, FieldValue fv) Data descriptors defined here: __dict__ dictionary for instance variables (if defined) __weakref__ list of weak references to the object (if defined) field_values TuplePrivateImpl_field_values_get(TuplePrivateImpl self) -> FieldValueVector id TuplePrivateImpl_id_get(TuplePrivateImpl self) -> unsigned int schema TuplePrivateImpl_schema_get(TuplePrivateImpl self) -> Schema Data and other attributes defined here: __swig_destroy__ = <built-in function delete_TuplePrivateImpl> delete_TuplePrivateImpl(TuplePrivateImpl self) __swig_getmethods__ = {'copyFieldValueIntoBuffer': <function <lambda>>, 'extractBlob': <function <lambda>>, 'extractBool': <function <lambda>>, 'extractDouble': <function <lambda>>, 'extractFunction': <function <lambda>>, 'extractInt': <function <lambda>>, 'extractList': <function <lambda>>, 'extractLong': <function <lambda>>, 'extractString': <function <lambda>>, 'extractTimestamp': <function <lambda>>, ...} __swig_setmethods__ = {'field_values': <built-in function TuplePrivateImpl_field_values_set>, 'id': <built-in function TuplePrivateImpl_id_set>, 'schema': <built-in function TuplePrivateImpl_schema_set>}   class TupleVector(__builtin__.object)     Proxy of C++ std::vector<(sb::Tuple)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> TupleVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> TupleVector __init__(self, *args) __init__(self) -> TupleVector __init__(self, TupleVector arg0) -> TupleVector __init__(self, size_type size) -> TupleVector __init__(self, size_type size, value_type value) -> TupleVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, TupleVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, TupleVector v = std::vector< sb::Tuple,std::allocator< sb::Tuple > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, TupleVector v) 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: __swig_destroy__ = <built-in function delete_TupleVector> delete_TupleVector(TupleVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class URI(__builtin__.object)     A URI for a StreamBase client connection.     These URIs are of the form         /// sb://hostname:port/;param1=val1;param2=val2     ///         e.g.,       erbatim  /// sb://somehost.mycompany.com:10000/;user=me;password=foobar ///         Parameters are optional.  The port number is optional; it defaults     to 10000.      C++ includes: StreamBaseURI.hpp     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self, *args) StreamBaseURI() -> URI StreamBaseURI(string uri) -> URI StreamBaseURI(string host, unsigned int port, string user = "", string password = "") -> URI StreamBaseURI(string host, unsigned int port, string user = "") -> URI StreamBaseURI(string host, unsigned int port) -> URI StreamBaseURI(string host, string container, unsigned int port, string user = "",      string password = "") -> URI StreamBaseURI(string host, string container, unsigned int port, string user = "") -> URI StreamBaseURI(string host, string container, unsigned int port) -> URI StreamBaseURI(string host, unsigned int port, ParamMap paramMap) -> URI __init__(self, string host, string container, unsigned int port, ParamMap paramMap) -> URI   sb::StreamBaseURI::StreamBaseURI Create explicitly from host/port with container, including a map of parameters. __nonzero__(self) x.__nonzero__() <==> x != 0 __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __str__(self, *args) x.__str__() <==> str(x) x.__str__() <==> str(x)   sb::StreamBaseURI::as_string Return a string representation of a list of uris. addParameter(self, *args) addParameter(self, string key, string value)   sb::StreamBaseURI::addParameter Add a parameter. getBaseURI(self) getBaseURI(self) -> URI   sb::StreamBaseURI::getBaseURI return a StreamBaseURI without Parameters getContainer(self) getContainer(self) -> string   sb::StreamBaseURI::getContainer Returns the container name component of the URI.     May return an empty string if no container was specified. getHost(self) getHost(self) -> string   sb::StreamBaseURI::getHost Return the host component of the URI. getNumParameters(self) getNumParameters(self) -> size_t   sb::StreamBaseURI::getNumParameters return the number of parameters getParam(self, *args) getParam(self, string key) -> string   sb::StreamBaseURI::getParam Return a parameter, or empty string if undefined. getParameter(self, *args) getParameter(self, string key) -> string getParameter(self, string key, string value) -> bool   sb::StreamBaseURI::getParameter Return a parameter into value (returning true if one was found).     Useful to distinguish an undefined parameter from an empty one. getPassword(self) getPassword(self) -> string   sb::StreamBaseURI::getPassword Return the password component of the URI. getPort(self) getPort(self) -> unsigned int   sb::StreamBaseURI::getPort Return the port component of the URI. getUser(self) getUser(self) -> string   sb::StreamBaseURI::getUser Return the user name component of the URI. removeParameter(self, *args) removeParameter(self, string key)   sb::StreamBaseURI::removeParameter Add a parameter. Static methods defined here: fromEnvironment() fromEnvironment() -> URI   sb::StreamBaseURI::fromEnvironment Create from the environment variable. vectorFromEnvironment() vectorFromEnvironment() -> URIVector   sb::StreamBaseURI::vectorFromEnvironment Create from the environment variable and return a vector of StreamBaseURIs. vectorFromString(*args) vectorFromString(string uris) -> URIVector   sb::StreamBaseURI::vectorFromString Return a StreamBaseURI vector from a string of comma sepearted URIs.     The string of URIs supplied must conform to a valid HA URI list, for example they must all reference the same container. 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: DEFAULT = <streambase.URI; proxy of <Swig Object of type 'sb::StreamBaseURI *' at 0x7f50c5e95690> > DEFAULT_CONTAINER = 'default' DEFAULT_HOST = 'localhost' DEFAULT_NODE_MANAGER_PORT = 10002 DEFAULT_PORT = 10000 DEFAULT_URI = <streambase.URI; proxy of <Swig Object of type 'sb::StreamBaseURI *' at 0x7f50c5e95f30> > ENVIRONMENT_VARIABLE = 'STREAMBASE_SERVER' NO_CONTAINER = '' PASSWORD_PARAM = 'password' SYSTEM_CONTAINER = 'system' URI_ENVIRONMENT_VARIABLE = 'STREAMBASE_URI' URI_PROPERTY_NAME = 'streambase.uri' USERNAME_PARAM = 'username' USER_PARAM = 'user' __swig_destroy__ = <built-in function delete_URI> delete_URI(URI self) __swig_getmethods__ = {'fromEnvironment': <function <lambda>>, 'vectorFromEnvironment': <function <lambda>>, 'vectorFromString': <function <lambda>>} __swig_setmethods__ = {}   class URIVector(__builtin__.object)     Proxy of C++ std::vector<(sb::StreamBaseURI)> class     Methods defined here: __bool__(self) __bool__(self) -> bool __del__ lambda self __delitem__(self, *args) __delitem__(self, difference_type i) __delitem__(self, PySliceObject slice) __delslice__(self, *args) __delslice__(self, difference_type i, difference_type j) __getattr__ lambda self, name __getitem__(self, *args) __getitem__(self, PySliceObject slice) -> URIVector __getitem__(self, difference_type i) -> value_type __getslice__(self, *args) __getslice__(self, difference_type i, difference_type j) -> URIVector __init__(self, *args) __init__(self) -> URIVector __init__(self, URIVector arg0) -> URIVector __init__(self, size_type size) -> URIVector __init__(self, size_type size, value_type value) -> URIVector __iter__(self) __len__(self) __len__(self) -> size_type __nonzero__(self) __nonzero__(self) -> bool __repr__ = _swig_repr(self) __setattr__ lambda self, name, value __setitem__(self, *args) __setitem__(self, PySliceObject slice, URIVector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) __setslice__(self, *args) __setslice__(self, difference_type i, difference_type j, URIVector v = std::vector< sb::StreamBaseURI,std::allocator< sb::StreamBaseURI > >()) __setslice__(self, difference_type i, difference_type j) append(self, *args) append(self, value_type x) assign(self, *args) assign(self, size_type n, value_type x) back(self) back(self) -> value_type begin(self) begin(self) -> iterator capacity(self) capacity(self) -> size_type clear(self) clear(self) empty(self) empty(self) -> bool end(self) end(self) -> iterator erase(self, *args) erase(self, iterator pos) -> iterator erase(self, iterator first, iterator last) -> iterator front(self) front(self) -> value_type get_allocator(self) get_allocator(self) -> allocator_type insert(self, *args) insert(self, iterator pos, value_type x) -> iterator insert(self, iterator pos, size_type n, value_type x) iterator(self) iterator(self) -> SwigPyIterator pop(self) pop(self) -> value_type pop_back(self) pop_back(self) push_back(self, *args) push_back(self, value_type x) rbegin(self) rbegin(self) -> reverse_iterator rend(self) rend(self) -> reverse_iterator reserve(self, *args) reserve(self, size_type n) resize(self, *args) resize(self, size_type new_size) resize(self, size_type new_size, value_type x) size(self) size(self) -> size_type swap(self, *args) swap(self, URIVector v) 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: __swig_destroy__ = <built-in function delete_URIVector> delete_URIVector(URIVector self) __swig_getmethods__ = {} __swig_setmethods__ = {}   class Version(__builtin__.object)     Proxy of C++ sb::StreamBaseVersion class     Methods defined here: __del__ lambda self __getattr__ lambda self, name __init__(self) __init__(self) -> Version __repr__ = _swig_repr(self) __setattr__ lambda self, name, value Static methods defined here: checkPrintVersion(*args) checkPrintVersion(int argc, char argv) -> bool 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: BUILD_STRING = '2409250543' INFO_LINE = 'Spotfire Streaming 11.1.1 2409250543' VERSION_STRING = '11.1.1' __swig_destroy__ = <built-in function delete_Version> delete_Version(Version self) __swig_getmethods__ = {'checkPrintVersion': <function <lambda>>} __swig_setmethods__ = {}