swigibpy.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.


import warnings
import sys
import threading
import select
from traceback import print_exc, print_exception




"""
Python wrapper for Interactive Brokers TWS C++ API
"""


from sys import version_info
if version_info >= (3, 0, 0):
    new_instancemethod = lambda func, inst, cls: _swigibpy.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_swigibpy', [dirname(__file__)])
        except ImportError:
            import _swigibpy
            return _swigibpy
        if fp is not None:
            try:
                _mod = imp.load_module('_swigibpy', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _swigibpy = swig_import_helper()
    del swig_import_helper
else:
    import _swigibpy
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class SwigPyIterator(object):
    """Proxy of C++ swig::SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _swigibpy.delete_SwigPyIterator

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _swigibpy.SwigPyIterator_value(self)


    def incr(self, n=1):
        """incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _swigibpy.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _swigibpy.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator_copy(self)


    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _swigibpy.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _swigibpy.SwigPyIterator___next__(self)


    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _swigibpy.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _swigibpy.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _swigibpy.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _swigibpy.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _swigibpy.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator.value = new_instancemethod(_swigibpy.SwigPyIterator_value, None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_swigibpy.SwigPyIterator_incr, None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_swigibpy.SwigPyIterator_decr, None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_swigibpy.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_swigibpy.SwigPyIterator_equal, None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_swigibpy.SwigPyIterator_copy, None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_swigibpy.SwigPyIterator_next, None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_swigibpy.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_swigibpy.SwigPyIterator_previous, None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_swigibpy.SwigPyIterator_advance, None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_swigibpy.SwigPyIterator___eq__, None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_swigibpy.SwigPyIterator___ne__, None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_swigibpy.SwigPyIterator___iadd__, None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_swigibpy.SwigPyIterator___isub__, None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_swigibpy.SwigPyIterator___add__, None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_swigibpy.SwigPyIterator___sub__, None, SwigPyIterator)
SwigPyIterator_swigregister = _swigibpy.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


_swigibpy.SHARED_PTR_DISOWN_swigconstant(_swigibpy)
SHARED_PTR_DISOWN = _swigibpy.SHARED_PTR_DISOWN
class ComboLegList(object):
    """Proxy of C++ std::vector<(shared_ptr<(ComboLeg)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ComboLegList self) -> SwigPyIterator"""
        return _swigibpy.ComboLegList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ComboLegList self) -> bool"""
        return _swigibpy.ComboLegList___nonzero__(self)


    def __bool__(self):
        """__bool__(ComboLegList self) -> bool"""
        return _swigibpy.ComboLegList___bool__(self)


    def __len__(self):
        """__len__(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::size_type"""
        return _swigibpy.ComboLegList___len__(self)


    def pop(self):
        """pop(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::value_type"""
        return _swigibpy.ComboLegList_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::difference_type i, std::vector< shared_ptr< ComboLeg > >::difference_type j) -> ComboLegList"""
        return _swigibpy.ComboLegList___getslice__(self, i, j)


    def __setslice__(self, *args, **kwargs):
        """__setslice__(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::difference_type i, std::vector< shared_ptr< ComboLeg > >::difference_type j, ComboLegList v)"""
        return _swigibpy.ComboLegList___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__delslice__(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::difference_type i, std::vector< shared_ptr< ComboLeg > >::difference_type j)"""
        return _swigibpy.ComboLegList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::difference_type i)
        __delitem__(ComboLegList self, PySliceObject * slice)
        """
        return _swigibpy.ComboLegList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ComboLegList self, PySliceObject * slice) -> ComboLegList
        __getitem__(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::difference_type i) -> std::vector< shared_ptr< ComboLeg > >::value_type const &
        """
        return _swigibpy.ComboLegList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ComboLegList self, PySliceObject * slice, ComboLegList v)
        __setitem__(ComboLegList self, PySliceObject * slice)
        __setitem__(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::difference_type i, std::vector< shared_ptr< ComboLeg > >::value_type const & x)
        """
        return _swigibpy.ComboLegList___setitem__(self, *args)


    def append(self, x):
        """append(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::value_type const & x)"""
        return _swigibpy.ComboLegList_append(self, x)


    def empty(self):
        """empty(ComboLegList self) -> bool"""
        return _swigibpy.ComboLegList_empty(self)


    def size(self):
        """size(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::size_type"""
        return _swigibpy.ComboLegList_size(self)


    def clear(self):
        """clear(ComboLegList self)"""
        return _swigibpy.ComboLegList_clear(self)


    def swap(self, v):
        """swap(ComboLegList self, ComboLegList v)"""
        return _swigibpy.ComboLegList_swap(self, v)


    def get_allocator(self):
        """get_allocator(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::allocator_type"""
        return _swigibpy.ComboLegList_get_allocator(self)


    def begin(self):
        """begin(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::iterator"""
        return _swigibpy.ComboLegList_begin(self)


    def end(self):
        """end(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::iterator"""
        return _swigibpy.ComboLegList_end(self)


    def rbegin(self):
        """rbegin(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::reverse_iterator"""
        return _swigibpy.ComboLegList_rbegin(self)


    def rend(self):
        """rend(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::reverse_iterator"""
        return _swigibpy.ComboLegList_rend(self)


    def pop_back(self):
        """pop_back(ComboLegList self)"""
        return _swigibpy.ComboLegList_pop_back(self)


    def erase(self, *args):
        """
        erase(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::iterator pos) -> std::vector< shared_ptr< ComboLeg > >::iterator
        erase(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::iterator first, std::vector< shared_ptr< ComboLeg > >::iterator last) -> std::vector< shared_ptr< ComboLeg > >::iterator
        """
        return _swigibpy.ComboLegList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(shared_ptr<(ComboLeg)>)> self) -> ComboLegList
        __init__(std::vector<(shared_ptr<(ComboLeg)>)> self, ComboLegList arg2) -> ComboLegList
        __init__(std::vector<(shared_ptr<(ComboLeg)>)> self, std::vector< shared_ptr< ComboLeg > >::size_type size) -> ComboLegList
        __init__(std::vector<(shared_ptr<(ComboLeg)>)> self, std::vector< shared_ptr< ComboLeg > >::size_type size, std::vector< shared_ptr< ComboLeg > >::value_type const & value) -> ComboLegList
        """
        _swigibpy.ComboLegList_swiginit(self, _swigibpy.new_ComboLegList(*args))

    def push_back(self, x):
        """push_back(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::value_type const & x)"""
        return _swigibpy.ComboLegList_push_back(self, x)


    def front(self):
        """front(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::value_type const &"""
        return _swigibpy.ComboLegList_front(self)


    def back(self):
        """back(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::value_type const &"""
        return _swigibpy.ComboLegList_back(self)


    def assign(self, n, x):
        """assign(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::size_type n, std::vector< shared_ptr< ComboLeg > >::value_type const & x)"""
        return _swigibpy.ComboLegList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::size_type new_size)
        resize(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::size_type new_size, std::vector< shared_ptr< ComboLeg > >::value_type const & x)
        """
        return _swigibpy.ComboLegList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::iterator pos, std::vector< shared_ptr< ComboLeg > >::value_type const & x) -> std::vector< shared_ptr< ComboLeg > >::iterator
        insert(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::iterator pos, std::vector< shared_ptr< ComboLeg > >::size_type n, std::vector< shared_ptr< ComboLeg > >::value_type const & x)
        """
        return _swigibpy.ComboLegList_insert(self, *args)


    def reserve(self, n):
        """reserve(ComboLegList self, std::vector< shared_ptr< ComboLeg > >::size_type n)"""
        return _swigibpy.ComboLegList_reserve(self, n)


    def capacity(self):
        """capacity(ComboLegList self) -> std::vector< shared_ptr< ComboLeg > >::size_type"""
        return _swigibpy.ComboLegList_capacity(self)

    __swig_destroy__ = _swigibpy.delete_ComboLegList
ComboLegList.iterator = new_instancemethod(_swigibpy.ComboLegList_iterator, None, ComboLegList)
ComboLegList.__nonzero__ = new_instancemethod(_swigibpy.ComboLegList___nonzero__, None, ComboLegList)
ComboLegList.__bool__ = new_instancemethod(_swigibpy.ComboLegList___bool__, None, ComboLegList)
ComboLegList.__len__ = new_instancemethod(_swigibpy.ComboLegList___len__, None, ComboLegList)
ComboLegList.pop = new_instancemethod(_swigibpy.ComboLegList_pop, None, ComboLegList)
ComboLegList.__getslice__ = new_instancemethod(_swigibpy.ComboLegList___getslice__, None, ComboLegList)
ComboLegList.__setslice__ = new_instancemethod(_swigibpy.ComboLegList___setslice__, None, ComboLegList)
ComboLegList.__delslice__ = new_instancemethod(_swigibpy.ComboLegList___delslice__, None, ComboLegList)
ComboLegList.__delitem__ = new_instancemethod(_swigibpy.ComboLegList___delitem__, None, ComboLegList)
ComboLegList.__getitem__ = new_instancemethod(_swigibpy.ComboLegList___getitem__, None, ComboLegList)
ComboLegList.__setitem__ = new_instancemethod(_swigibpy.ComboLegList___setitem__, None, ComboLegList)
ComboLegList.append = new_instancemethod(_swigibpy.ComboLegList_append, None, ComboLegList)
ComboLegList.empty = new_instancemethod(_swigibpy.ComboLegList_empty, None, ComboLegList)
ComboLegList.size = new_instancemethod(_swigibpy.ComboLegList_size, None, ComboLegList)
ComboLegList.clear = new_instancemethod(_swigibpy.ComboLegList_clear, None, ComboLegList)
ComboLegList.swap = new_instancemethod(_swigibpy.ComboLegList_swap, None, ComboLegList)
ComboLegList.get_allocator = new_instancemethod(_swigibpy.ComboLegList_get_allocator, None, ComboLegList)
ComboLegList.begin = new_instancemethod(_swigibpy.ComboLegList_begin, None, ComboLegList)
ComboLegList.end = new_instancemethod(_swigibpy.ComboLegList_end, None, ComboLegList)
ComboLegList.rbegin = new_instancemethod(_swigibpy.ComboLegList_rbegin, None, ComboLegList)
ComboLegList.rend = new_instancemethod(_swigibpy.ComboLegList_rend, None, ComboLegList)
ComboLegList.pop_back = new_instancemethod(_swigibpy.ComboLegList_pop_back, None, ComboLegList)
ComboLegList.erase = new_instancemethod(_swigibpy.ComboLegList_erase, None, ComboLegList)
ComboLegList.push_back = new_instancemethod(_swigibpy.ComboLegList_push_back, None, ComboLegList)
ComboLegList.front = new_instancemethod(_swigibpy.ComboLegList_front, None, ComboLegList)
ComboLegList.back = new_instancemethod(_swigibpy.ComboLegList_back, None, ComboLegList)
ComboLegList.assign = new_instancemethod(_swigibpy.ComboLegList_assign, None, ComboLegList)
ComboLegList.resize = new_instancemethod(_swigibpy.ComboLegList_resize, None, ComboLegList)
ComboLegList.insert = new_instancemethod(_swigibpy.ComboLegList_insert, None, ComboLegList)
ComboLegList.reserve = new_instancemethod(_swigibpy.ComboLegList_reserve, None, ComboLegList)
ComboLegList.capacity = new_instancemethod(_swigibpy.ComboLegList_capacity, None, ComboLegList)
ComboLegList_swigregister = _swigibpy.ComboLegList_swigregister
ComboLegList_swigregister(ComboLegList)

class OrderComboLegList(object):
    """Proxy of C++ std::vector<(shared_ptr<(OrderComboLeg)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(OrderComboLegList self) -> SwigPyIterator"""
        return _swigibpy.OrderComboLegList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(OrderComboLegList self) -> bool"""
        return _swigibpy.OrderComboLegList___nonzero__(self)


    def __bool__(self):
        """__bool__(OrderComboLegList self) -> bool"""
        return _swigibpy.OrderComboLegList___bool__(self)


    def __len__(self):
        """__len__(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::size_type"""
        return _swigibpy.OrderComboLegList___len__(self)


    def pop(self):
        """pop(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::value_type"""
        return _swigibpy.OrderComboLegList_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::difference_type i, std::vector< shared_ptr< OrderComboLeg > >::difference_type j) -> OrderComboLegList"""
        return _swigibpy.OrderComboLegList___getslice__(self, i, j)


    def __setslice__(self, *args, **kwargs):
        """__setslice__(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::difference_type i, std::vector< shared_ptr< OrderComboLeg > >::difference_type j, OrderComboLegList v)"""
        return _swigibpy.OrderComboLegList___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__delslice__(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::difference_type i, std::vector< shared_ptr< OrderComboLeg > >::difference_type j)"""
        return _swigibpy.OrderComboLegList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::difference_type i)
        __delitem__(OrderComboLegList self, PySliceObject * slice)
        """
        return _swigibpy.OrderComboLegList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(OrderComboLegList self, PySliceObject * slice) -> OrderComboLegList
        __getitem__(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::difference_type i) -> std::vector< shared_ptr< OrderComboLeg > >::value_type const &
        """
        return _swigibpy.OrderComboLegList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(OrderComboLegList self, PySliceObject * slice, OrderComboLegList v)
        __setitem__(OrderComboLegList self, PySliceObject * slice)
        __setitem__(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::difference_type i, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x)
        """
        return _swigibpy.OrderComboLegList___setitem__(self, *args)


    def append(self, x):
        """append(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x)"""
        return _swigibpy.OrderComboLegList_append(self, x)


    def empty(self):
        """empty(OrderComboLegList self) -> bool"""
        return _swigibpy.OrderComboLegList_empty(self)


    def size(self):
        """size(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::size_type"""
        return _swigibpy.OrderComboLegList_size(self)


    def clear(self):
        """clear(OrderComboLegList self)"""
        return _swigibpy.OrderComboLegList_clear(self)


    def swap(self, v):
        """swap(OrderComboLegList self, OrderComboLegList v)"""
        return _swigibpy.OrderComboLegList_swap(self, v)


    def get_allocator(self):
        """get_allocator(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::allocator_type"""
        return _swigibpy.OrderComboLegList_get_allocator(self)


    def begin(self):
        """begin(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::iterator"""
        return _swigibpy.OrderComboLegList_begin(self)


    def end(self):
        """end(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::iterator"""
        return _swigibpy.OrderComboLegList_end(self)


    def rbegin(self):
        """rbegin(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::reverse_iterator"""
        return _swigibpy.OrderComboLegList_rbegin(self)


    def rend(self):
        """rend(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::reverse_iterator"""
        return _swigibpy.OrderComboLegList_rend(self)


    def pop_back(self):
        """pop_back(OrderComboLegList self)"""
        return _swigibpy.OrderComboLegList_pop_back(self)


    def erase(self, *args):
        """
        erase(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::iterator pos) -> std::vector< shared_ptr< OrderComboLeg > >::iterator
        erase(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::iterator first, std::vector< shared_ptr< OrderComboLeg > >::iterator last) -> std::vector< shared_ptr< OrderComboLeg > >::iterator
        """
        return _swigibpy.OrderComboLegList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(shared_ptr<(OrderComboLeg)>)> self) -> OrderComboLegList
        __init__(std::vector<(shared_ptr<(OrderComboLeg)>)> self, OrderComboLegList arg2) -> OrderComboLegList
        __init__(std::vector<(shared_ptr<(OrderComboLeg)>)> self, std::vector< shared_ptr< OrderComboLeg > >::size_type size) -> OrderComboLegList
        __init__(std::vector<(shared_ptr<(OrderComboLeg)>)> self, std::vector< shared_ptr< OrderComboLeg > >::size_type size, std::vector< shared_ptr< OrderComboLeg > >::value_type const & value) -> OrderComboLegList
        """
        _swigibpy.OrderComboLegList_swiginit(self, _swigibpy.new_OrderComboLegList(*args))

    def push_back(self, x):
        """push_back(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x)"""
        return _swigibpy.OrderComboLegList_push_back(self, x)


    def front(self):
        """front(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::value_type const &"""
        return _swigibpy.OrderComboLegList_front(self)


    def back(self):
        """back(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::value_type const &"""
        return _swigibpy.OrderComboLegList_back(self)


    def assign(self, n, x):
        """assign(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::size_type n, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x)"""
        return _swigibpy.OrderComboLegList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::size_type new_size)
        resize(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::size_type new_size, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x)
        """
        return _swigibpy.OrderComboLegList_resize(self, *args)


    def insert(self, *args):
        """
        insert(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::iterator pos, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x) -> std::vector< shared_ptr< OrderComboLeg > >::iterator
        insert(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::iterator pos, std::vector< shared_ptr< OrderComboLeg > >::size_type n, std::vector< shared_ptr< OrderComboLeg > >::value_type const & x)
        """
        return _swigibpy.OrderComboLegList_insert(self, *args)


    def reserve(self, n):
        """reserve(OrderComboLegList self, std::vector< shared_ptr< OrderComboLeg > >::size_type n)"""
        return _swigibpy.OrderComboLegList_reserve(self, n)


    def capacity(self):
        """capacity(OrderComboLegList self) -> std::vector< shared_ptr< OrderComboLeg > >::size_type"""
        return _swigibpy.OrderComboLegList_capacity(self)

    __swig_destroy__ = _swigibpy.delete_OrderComboLegList
OrderComboLegList.iterator = new_instancemethod(_swigibpy.OrderComboLegList_iterator, None, OrderComboLegList)
OrderComboLegList.__nonzero__ = new_instancemethod(_swigibpy.OrderComboLegList___nonzero__, None, OrderComboLegList)
OrderComboLegList.__bool__ = new_instancemethod(_swigibpy.OrderComboLegList___bool__, None, OrderComboLegList)
OrderComboLegList.__len__ = new_instancemethod(_swigibpy.OrderComboLegList___len__, None, OrderComboLegList)
OrderComboLegList.pop = new_instancemethod(_swigibpy.OrderComboLegList_pop, None, OrderComboLegList)
OrderComboLegList.__getslice__ = new_instancemethod(_swigibpy.OrderComboLegList___getslice__, None, OrderComboLegList)
OrderComboLegList.__setslice__ = new_instancemethod(_swigibpy.OrderComboLegList___setslice__, None, OrderComboLegList)
OrderComboLegList.__delslice__ = new_instancemethod(_swigibpy.OrderComboLegList___delslice__, None, OrderComboLegList)
OrderComboLegList.__delitem__ = new_instancemethod(_swigibpy.OrderComboLegList___delitem__, None, OrderComboLegList)
OrderComboLegList.__getitem__ = new_instancemethod(_swigibpy.OrderComboLegList___getitem__, None, OrderComboLegList)
OrderComboLegList.__setitem__ = new_instancemethod(_swigibpy.OrderComboLegList___setitem__, None, OrderComboLegList)
OrderComboLegList.append = new_instancemethod(_swigibpy.OrderComboLegList_append, None, OrderComboLegList)
OrderComboLegList.empty = new_instancemethod(_swigibpy.OrderComboLegList_empty, None, OrderComboLegList)
OrderComboLegList.size = new_instancemethod(_swigibpy.OrderComboLegList_size, None, OrderComboLegList)
OrderComboLegList.clear = new_instancemethod(_swigibpy.OrderComboLegList_clear, None, OrderComboLegList)
OrderComboLegList.swap = new_instancemethod(_swigibpy.OrderComboLegList_swap, None, OrderComboLegList)
OrderComboLegList.get_allocator = new_instancemethod(_swigibpy.OrderComboLegList_get_allocator, None, OrderComboLegList)
OrderComboLegList.begin = new_instancemethod(_swigibpy.OrderComboLegList_begin, None, OrderComboLegList)
OrderComboLegList.end = new_instancemethod(_swigibpy.OrderComboLegList_end, None, OrderComboLegList)
OrderComboLegList.rbegin = new_instancemethod(_swigibpy.OrderComboLegList_rbegin, None, OrderComboLegList)
OrderComboLegList.rend = new_instancemethod(_swigibpy.OrderComboLegList_rend, None, OrderComboLegList)
OrderComboLegList.pop_back = new_instancemethod(_swigibpy.OrderComboLegList_pop_back, None, OrderComboLegList)
OrderComboLegList.erase = new_instancemethod(_swigibpy.OrderComboLegList_erase, None, OrderComboLegList)
OrderComboLegList.push_back = new_instancemethod(_swigibpy.OrderComboLegList_push_back, None, OrderComboLegList)
OrderComboLegList.front = new_instancemethod(_swigibpy.OrderComboLegList_front, None, OrderComboLegList)
OrderComboLegList.back = new_instancemethod(_swigibpy.OrderComboLegList_back, None, OrderComboLegList)
OrderComboLegList.assign = new_instancemethod(_swigibpy.OrderComboLegList_assign, None, OrderComboLegList)
OrderComboLegList.resize = new_instancemethod(_swigibpy.OrderComboLegList_resize, None, OrderComboLegList)
OrderComboLegList.insert = new_instancemethod(_swigibpy.OrderComboLegList_insert, None, OrderComboLegList)
OrderComboLegList.reserve = new_instancemethod(_swigibpy.OrderComboLegList_reserve, None, OrderComboLegList)
OrderComboLegList.capacity = new_instancemethod(_swigibpy.OrderComboLegList_capacity, None, OrderComboLegList)
OrderComboLegList_swigregister = _swigibpy.OrderComboLegList_swigregister
OrderComboLegList_swigregister(OrderComboLegList)

class TagValueList(object):
    """Proxy of C++ std::vector<(shared_ptr<(TagValue)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(TagValueList self) -> SwigPyIterator"""
        return _swigibpy.TagValueList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(TagValueList self) -> bool"""
        return _swigibpy.TagValueList___nonzero__(self)


    def __bool__(self):
        """__bool__(TagValueList self) -> bool"""
        return _swigibpy.TagValueList___bool__(self)


    def __len__(self):
        """__len__(TagValueList self) -> std::vector< shared_ptr< TagValue > >::size_type"""
        return _swigibpy.TagValueList___len__(self)


    def pop(self):
        """pop(TagValueList self) -> std::vector< shared_ptr< TagValue > >::value_type"""
        return _swigibpy.TagValueList_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(TagValueList self, std::vector< shared_ptr< TagValue > >::difference_type i, std::vector< shared_ptr< TagValue > >::difference_type j) -> TagValueList"""
        return _swigibpy.TagValueList___getslice__(self, i, j)


    def __setslice__(self, *args, **kwargs):
        """__setslice__(TagValueList self, std::vector< shared_ptr< TagValue > >::difference_type i, std::vector< shared_ptr< TagValue > >::difference_type j, TagValueList v)"""
        return _swigibpy.TagValueList___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__delslice__(TagValueList self, std::vector< shared_ptr< TagValue > >::difference_type i, std::vector< shared_ptr< TagValue > >::difference_type j)"""
        return _swigibpy.TagValueList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(TagValueList self, std::vector< shared_ptr< TagValue > >::difference_type i)
        __delitem__(TagValueList self, PySliceObject * slice)
        """
        return _swigibpy.TagValueList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(TagValueList self, PySliceObject * slice) -> TagValueList
        __getitem__(TagValueList self, std::vector< shared_ptr< TagValue > >::difference_type i) -> std::vector< shared_ptr< TagValue > >::value_type const &
        """
        return _swigibpy.TagValueList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(TagValueList self, PySliceObject * slice, TagValueList v)
        __setitem__(TagValueList self, PySliceObject * slice)
        __setitem__(TagValueList self, std::vector< shared_ptr< TagValue > >::difference_type i, std::vector< shared_ptr< TagValue > >::value_type const & x)
        """
        return _swigibpy.TagValueList___setitem__(self, *args)


    def append(self, x):
        """append(TagValueList self, std::vector< shared_ptr< TagValue > >::value_type const & x)"""
        return _swigibpy.TagValueList_append(self, x)


    def empty(self):
        """empty(TagValueList self) -> bool"""
        return _swigibpy.TagValueList_empty(self)


    def size(self):
        """size(TagValueList self) -> std::vector< shared_ptr< TagValue > >::size_type"""
        return _swigibpy.TagValueList_size(self)


    def clear(self):
        """clear(TagValueList self)"""
        return _swigibpy.TagValueList_clear(self)


    def swap(self, v):
        """swap(TagValueList self, TagValueList v)"""
        return _swigibpy.TagValueList_swap(self, v)


    def get_allocator(self):
        """get_allocator(TagValueList self) -> std::vector< shared_ptr< TagValue > >::allocator_type"""
        return _swigibpy.TagValueList_get_allocator(self)


    def begin(self):
        """begin(TagValueList self) -> std::vector< shared_ptr< TagValue > >::iterator"""
        return _swigibpy.TagValueList_begin(self)


    def end(self):
        """end(TagValueList self) -> std::vector< shared_ptr< TagValue > >::iterator"""
        return _swigibpy.TagValueList_end(self)


    def rbegin(self):
        """rbegin(TagValueList self) -> std::vector< shared_ptr< TagValue > >::reverse_iterator"""
        return _swigibpy.TagValueList_rbegin(self)


    def rend(self):
        """rend(TagValueList self) -> std::vector< shared_ptr< TagValue > >::reverse_iterator"""
        return _swigibpy.TagValueList_rend(self)


    def pop_back(self):
        """pop_back(TagValueList self)"""
        return _swigibpy.TagValueList_pop_back(self)


    def erase(self, *args):
        """
        erase(TagValueList self, std::vector< shared_ptr< TagValue > >::iterator pos) -> std::vector< shared_ptr< TagValue > >::iterator
        erase(TagValueList self, std::vector< shared_ptr< TagValue > >::iterator first, std::vector< shared_ptr< TagValue > >::iterator last) -> std::vector< shared_ptr< TagValue > >::iterator
        """
        return _swigibpy.TagValueList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(shared_ptr<(TagValue)>)> self) -> TagValueList
        __init__(std::vector<(shared_ptr<(TagValue)>)> self, TagValueList arg2) -> TagValueList
        __init__(std::vector<(shared_ptr<(TagValue)>)> self, std::vector< shared_ptr< TagValue > >::size_type size) -> TagValueList
        __init__(std::vector<(shared_ptr<(TagValue)>)> self, std::vector< shared_ptr< TagValue > >::size_type size, std::vector< shared_ptr< TagValue > >::value_type const & value) -> TagValueList
        """
        _swigibpy.TagValueList_swiginit(self, _swigibpy.new_TagValueList(*args))

    def push_back(self, x):
        """push_back(TagValueList self, std::vector< shared_ptr< TagValue > >::value_type const & x)"""
        return _swigibpy.TagValueList_push_back(self, x)


    def front(self):
        """front(TagValueList self) -> std::vector< shared_ptr< TagValue > >::value_type const &"""
        return _swigibpy.TagValueList_front(self)


    def back(self):
        """back(TagValueList self) -> std::vector< shared_ptr< TagValue > >::value_type const &"""
        return _swigibpy.TagValueList_back(self)


    def assign(self, n, x):
        """assign(TagValueList self, std::vector< shared_ptr< TagValue > >::size_type n, std::vector< shared_ptr< TagValue > >::value_type const & x)"""
        return _swigibpy.TagValueList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(TagValueList self, std::vector< shared_ptr< TagValue > >::size_type new_size)
        resize(TagValueList self, std::vector< shared_ptr< TagValue > >::size_type new_size, std::vector< shared_ptr< TagValue > >::value_type const & x)
        """
        return _swigibpy.TagValueList_resize(self, *args)


    def insert(self, *args):
        """
        insert(TagValueList self, std::vector< shared_ptr< TagValue > >::iterator pos, std::vector< shared_ptr< TagValue > >::value_type const & x) -> std::vector< shared_ptr< TagValue > >::iterator
        insert(TagValueList self, std::vector< shared_ptr< TagValue > >::iterator pos, std::vector< shared_ptr< TagValue > >::size_type n, std::vector< shared_ptr< TagValue > >::value_type const & x)
        """
        return _swigibpy.TagValueList_insert(self, *args)


    def reserve(self, n):
        """reserve(TagValueList self, std::vector< shared_ptr< TagValue > >::size_type n)"""
        return _swigibpy.TagValueList_reserve(self, n)


    def capacity(self):
        """capacity(TagValueList self) -> std::vector< shared_ptr< TagValue > >::size_type"""
        return _swigibpy.TagValueList_capacity(self)

    __swig_destroy__ = _swigibpy.delete_TagValueList
TagValueList.iterator = new_instancemethod(_swigibpy.TagValueList_iterator, None, TagValueList)
TagValueList.__nonzero__ = new_instancemethod(_swigibpy.TagValueList___nonzero__, None, TagValueList)
TagValueList.__bool__ = new_instancemethod(_swigibpy.TagValueList___bool__, None, TagValueList)
TagValueList.__len__ = new_instancemethod(_swigibpy.TagValueList___len__, None, TagValueList)
TagValueList.pop = new_instancemethod(_swigibpy.TagValueList_pop, None, TagValueList)
TagValueList.__getslice__ = new_instancemethod(_swigibpy.TagValueList___getslice__, None, TagValueList)
TagValueList.__setslice__ = new_instancemethod(_swigibpy.TagValueList___setslice__, None, TagValueList)
TagValueList.__delslice__ = new_instancemethod(_swigibpy.TagValueList___delslice__, None, TagValueList)
TagValueList.__delitem__ = new_instancemethod(_swigibpy.TagValueList___delitem__, None, TagValueList)
TagValueList.__getitem__ = new_instancemethod(_swigibpy.TagValueList___getitem__, None, TagValueList)
TagValueList.__setitem__ = new_instancemethod(_swigibpy.TagValueList___setitem__, None, TagValueList)
TagValueList.append = new_instancemethod(_swigibpy.TagValueList_append, None, TagValueList)
TagValueList.empty = new_instancemethod(_swigibpy.TagValueList_empty, None, TagValueList)
TagValueList.size = new_instancemethod(_swigibpy.TagValueList_size, None, TagValueList)
TagValueList.clear = new_instancemethod(_swigibpy.TagValueList_clear, None, TagValueList)
TagValueList.swap = new_instancemethod(_swigibpy.TagValueList_swap, None, TagValueList)
TagValueList.get_allocator = new_instancemethod(_swigibpy.TagValueList_get_allocator, None, TagValueList)
TagValueList.begin = new_instancemethod(_swigibpy.TagValueList_begin, None, TagValueList)
TagValueList.end = new_instancemethod(_swigibpy.TagValueList_end, None, TagValueList)
TagValueList.rbegin = new_instancemethod(_swigibpy.TagValueList_rbegin, None, TagValueList)
TagValueList.rend = new_instancemethod(_swigibpy.TagValueList_rend, None, TagValueList)
TagValueList.pop_back = new_instancemethod(_swigibpy.TagValueList_pop_back, None, TagValueList)
TagValueList.erase = new_instancemethod(_swigibpy.TagValueList_erase, None, TagValueList)
TagValueList.push_back = new_instancemethod(_swigibpy.TagValueList_push_back, None, TagValueList)
TagValueList.front = new_instancemethod(_swigibpy.TagValueList_front, None, TagValueList)
TagValueList.back = new_instancemethod(_swigibpy.TagValueList_back, None, TagValueList)
TagValueList.assign = new_instancemethod(_swigibpy.TagValueList_assign, None, TagValueList)
TagValueList.resize = new_instancemethod(_swigibpy.TagValueList_resize, None, TagValueList)
TagValueList.insert = new_instancemethod(_swigibpy.TagValueList_insert, None, TagValueList)
TagValueList.reserve = new_instancemethod(_swigibpy.TagValueList_reserve, None, TagValueList)
TagValueList.capacity = new_instancemethod(_swigibpy.TagValueList_capacity, None, TagValueList)
TagValueList_swigregister = _swigibpy.TagValueList_swigregister
TagValueList_swigregister(TagValueList)

class CommissionReport(object):
    """Proxy of C++ CommissionReport class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(CommissionReport self) -> CommissionReport"""
        _swigibpy.CommissionReport_swiginit(self, _swigibpy.new_CommissionReport())
    execId = _swig_property(_swigibpy.CommissionReport_execId_get, _swigibpy.CommissionReport_execId_set)
    commission = _swig_property(_swigibpy.CommissionReport_commission_get, _swigibpy.CommissionReport_commission_set)
    currency = _swig_property(_swigibpy.CommissionReport_currency_get, _swigibpy.CommissionReport_currency_set)
    realizedPNL = _swig_property(_swigibpy.CommissionReport_realizedPNL_get, _swigibpy.CommissionReport_realizedPNL_set)
    _yield = _swig_property(_swigibpy.CommissionReport__yield_get, _swigibpy.CommissionReport__yield_set)
    yieldRedemptionDate = _swig_property(_swigibpy.CommissionReport_yieldRedemptionDate_get, _swigibpy.CommissionReport_yieldRedemptionDate_set)
    __swig_destroy__ = _swigibpy.delete_CommissionReport
CommissionReport_swigregister = _swigibpy.CommissionReport_swigregister
CommissionReport_swigregister(CommissionReport)


_swigibpy.GROUPS_swigconstant(_swigibpy)
GROUPS = _swigibpy.GROUPS

_swigibpy.PROFILES_swigconstant(_swigibpy)
PROFILES = _swigibpy.PROFILES

_swigibpy.ALIASES_swigconstant(_swigibpy)
ALIASES = _swigibpy.ALIASES

def faDataTypeStr(pFaDataType):
    """faDataTypeStr(faDataType pFaDataType) -> char const *"""
    return _swigibpy.faDataTypeStr(pFaDataType)

_swigibpy.REALTIME_swigconstant(_swigibpy)
REALTIME = _swigibpy.REALTIME

_swigibpy.FROZEN_swigconstant(_swigibpy)
FROZEN = _swigibpy.FROZEN

_swigibpy.SAME_POS_swigconstant(_swigibpy)
SAME_POS = _swigibpy.SAME_POS

_swigibpy.OPEN_POS_swigconstant(_swigibpy)
OPEN_POS = _swigibpy.OPEN_POS

_swigibpy.CLOSE_POS_swigconstant(_swigibpy)
CLOSE_POS = _swigibpy.CLOSE_POS

_swigibpy.UNKNOWN_POS_swigconstant(_swigibpy)
UNKNOWN_POS = _swigibpy.UNKNOWN_POS
class ComboLeg(object):
    """Proxy of C++ ComboLeg class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ComboLeg self) -> ComboLeg"""
        _swigibpy.ComboLeg_swiginit(self, _swigibpy.new_ComboLeg())
    conId = _swig_property(_swigibpy.ComboLeg_conId_get, _swigibpy.ComboLeg_conId_set)
    ratio = _swig_property(_swigibpy.ComboLeg_ratio_get, _swigibpy.ComboLeg_ratio_set)
    action = _swig_property(_swigibpy.ComboLeg_action_get, _swigibpy.ComboLeg_action_set)
    exchange = _swig_property(_swigibpy.ComboLeg_exchange_get, _swigibpy.ComboLeg_exchange_set)
    openClose = _swig_property(_swigibpy.ComboLeg_openClose_get, _swigibpy.ComboLeg_openClose_set)
    shortSaleSlot = _swig_property(_swigibpy.ComboLeg_shortSaleSlot_get, _swigibpy.ComboLeg_shortSaleSlot_set)
    designatedLocation = _swig_property(_swigibpy.ComboLeg_designatedLocation_get, _swigibpy.ComboLeg_designatedLocation_set)
    exemptCode = _swig_property(_swigibpy.ComboLeg_exemptCode_get, _swigibpy.ComboLeg_exemptCode_set)

    def __eq__(self, other):
        """__eq__(ComboLeg self, ComboLeg other) -> bool"""
        return _swigibpy.ComboLeg___eq__(self, other)

    __swig_destroy__ = _swigibpy.delete_ComboLeg
ComboLeg.__eq__ = new_instancemethod(_swigibpy.ComboLeg___eq__, None, ComboLeg)
ComboLeg_swigregister = _swigibpy.ComboLeg_swigregister
ComboLeg_swigregister(ComboLeg)

class UnderComp(object):
    """Proxy of C++ UnderComp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(UnderComp self) -> UnderComp"""
        _swigibpy.UnderComp_swiginit(self, _swigibpy.new_UnderComp())
    conId = _swig_property(_swigibpy.UnderComp_conId_get, _swigibpy.UnderComp_conId_set)
    delta = _swig_property(_swigibpy.UnderComp_delta_get, _swigibpy.UnderComp_delta_set)
    price = _swig_property(_swigibpy.UnderComp_price_get, _swigibpy.UnderComp_price_set)
    __swig_destroy__ = _swigibpy.delete_UnderComp
UnderComp_swigregister = _swigibpy.UnderComp_swigregister
UnderComp_swigregister(UnderComp)

class Contract(object):
    """Proxy of C++ Contract class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(Contract self) -> Contract"""
        _swigibpy.Contract_swiginit(self, _swigibpy.new_Contract())
    conId = _swig_property(_swigibpy.Contract_conId_get, _swigibpy.Contract_conId_set)
    symbol = _swig_property(_swigibpy.Contract_symbol_get, _swigibpy.Contract_symbol_set)
    secType = _swig_property(_swigibpy.Contract_secType_get, _swigibpy.Contract_secType_set)
    expiry = _swig_property(_swigibpy.Contract_expiry_get, _swigibpy.Contract_expiry_set)
    strike = _swig_property(_swigibpy.Contract_strike_get, _swigibpy.Contract_strike_set)
    right = _swig_property(_swigibpy.Contract_right_get, _swigibpy.Contract_right_set)
    multiplier = _swig_property(_swigibpy.Contract_multiplier_get, _swigibpy.Contract_multiplier_set)
    exchange = _swig_property(_swigibpy.Contract_exchange_get, _swigibpy.Contract_exchange_set)
    primaryExchange = _swig_property(_swigibpy.Contract_primaryExchange_get, _swigibpy.Contract_primaryExchange_set)
    currency = _swig_property(_swigibpy.Contract_currency_get, _swigibpy.Contract_currency_set)
    localSymbol = _swig_property(_swigibpy.Contract_localSymbol_get, _swigibpy.Contract_localSymbol_set)
    tradingClass = _swig_property(_swigibpy.Contract_tradingClass_get, _swigibpy.Contract_tradingClass_set)
    includeExpired = _swig_property(_swigibpy.Contract_includeExpired_get, _swigibpy.Contract_includeExpired_set)
    secIdType = _swig_property(_swigibpy.Contract_secIdType_get, _swigibpy.Contract_secIdType_set)
    secId = _swig_property(_swigibpy.Contract_secId_get, _swigibpy.Contract_secId_set)
    comboLegsDescrip = _swig_property(_swigibpy.Contract_comboLegsDescrip_get, _swigibpy.Contract_comboLegsDescrip_set)
    comboLegs = _swig_property(_swigibpy.Contract_comboLegs_get, _swigibpy.Contract_comboLegs_set)
    underComp = _swig_property(_swigibpy.Contract_underComp_get, _swigibpy.Contract_underComp_set)

    def CloneComboLegs(dst, src):
        """CloneComboLegs(Contract::ComboLegListSPtr & dst, Contract::ComboLegListSPtr const & src)"""
        return _swigibpy.Contract_CloneComboLegs(dst, src)

    CloneComboLegs = staticmethod(CloneComboLegs)
    __swig_destroy__ = _swigibpy.delete_Contract
Contract_swigregister = _swigibpy.Contract_swigregister
Contract_swigregister(Contract)

def Contract_CloneComboLegs(dst, src):
    """Contract_CloneComboLegs(Contract::ComboLegListSPtr & dst, Contract::ComboLegListSPtr const & src)"""
    return _swigibpy.Contract_CloneComboLegs(dst, src)

class ContractDetails(object):
    """Proxy of C++ ContractDetails class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ContractDetails self) -> ContractDetails"""
        _swigibpy.ContractDetails_swiginit(self, _swigibpy.new_ContractDetails())
    summary = _swig_property(_swigibpy.ContractDetails_summary_get, _swigibpy.ContractDetails_summary_set)
    marketName = _swig_property(_swigibpy.ContractDetails_marketName_get, _swigibpy.ContractDetails_marketName_set)
    minTick = _swig_property(_swigibpy.ContractDetails_minTick_get, _swigibpy.ContractDetails_minTick_set)
    orderTypes = _swig_property(_swigibpy.ContractDetails_orderTypes_get, _swigibpy.ContractDetails_orderTypes_set)
    validExchanges = _swig_property(_swigibpy.ContractDetails_validExchanges_get, _swigibpy.ContractDetails_validExchanges_set)
    priceMagnifier = _swig_property(_swigibpy.ContractDetails_priceMagnifier_get, _swigibpy.ContractDetails_priceMagnifier_set)
    underConId = _swig_property(_swigibpy.ContractDetails_underConId_get, _swigibpy.ContractDetails_underConId_set)
    longName = _swig_property(_swigibpy.ContractDetails_longName_get, _swigibpy.ContractDetails_longName_set)
    contractMonth = _swig_property(_swigibpy.ContractDetails_contractMonth_get, _swigibpy.ContractDetails_contractMonth_set)
    industry = _swig_property(_swigibpy.ContractDetails_industry_get, _swigibpy.ContractDetails_industry_set)
    category = _swig_property(_swigibpy.ContractDetails_category_get, _swigibpy.ContractDetails_category_set)
    subcategory = _swig_property(_swigibpy.ContractDetails_subcategory_get, _swigibpy.ContractDetails_subcategory_set)
    timeZoneId = _swig_property(_swigibpy.ContractDetails_timeZoneId_get, _swigibpy.ContractDetails_timeZoneId_set)
    tradingHours = _swig_property(_swigibpy.ContractDetails_tradingHours_get, _swigibpy.ContractDetails_tradingHours_set)
    liquidHours = _swig_property(_swigibpy.ContractDetails_liquidHours_get, _swigibpy.ContractDetails_liquidHours_set)
    evRule = _swig_property(_swigibpy.ContractDetails_evRule_get, _swigibpy.ContractDetails_evRule_set)
    evMultiplier = _swig_property(_swigibpy.ContractDetails_evMultiplier_get, _swigibpy.ContractDetails_evMultiplier_set)
    secIdList = _swig_property(_swigibpy.ContractDetails_secIdList_get, _swigibpy.ContractDetails_secIdList_set)
    cusip = _swig_property(_swigibpy.ContractDetails_cusip_get, _swigibpy.ContractDetails_cusip_set)
    ratings = _swig_property(_swigibpy.ContractDetails_ratings_get, _swigibpy.ContractDetails_ratings_set)
    descAppend = _swig_property(_swigibpy.ContractDetails_descAppend_get, _swigibpy.ContractDetails_descAppend_set)
    bondType = _swig_property(_swigibpy.ContractDetails_bondType_get, _swigibpy.ContractDetails_bondType_set)
    couponType = _swig_property(_swigibpy.ContractDetails_couponType_get, _swigibpy.ContractDetails_couponType_set)
    callable = _swig_property(_swigibpy.ContractDetails_callable_get, _swigibpy.ContractDetails_callable_set)
    putable = _swig_property(_swigibpy.ContractDetails_putable_get, _swigibpy.ContractDetails_putable_set)
    coupon = _swig_property(_swigibpy.ContractDetails_coupon_get, _swigibpy.ContractDetails_coupon_set)
    convertible = _swig_property(_swigibpy.ContractDetails_convertible_get, _swigibpy.ContractDetails_convertible_set)
    maturity = _swig_property(_swigibpy.ContractDetails_maturity_get, _swigibpy.ContractDetails_maturity_set)
    issueDate = _swig_property(_swigibpy.ContractDetails_issueDate_get, _swigibpy.ContractDetails_issueDate_set)
    nextOptionDate = _swig_property(_swigibpy.ContractDetails_nextOptionDate_get, _swigibpy.ContractDetails_nextOptionDate_set)
    nextOptionType = _swig_property(_swigibpy.ContractDetails_nextOptionType_get, _swigibpy.ContractDetails_nextOptionType_set)
    nextOptionPartial = _swig_property(_swigibpy.ContractDetails_nextOptionPartial_get, _swigibpy.ContractDetails_nextOptionPartial_set)
    notes = _swig_property(_swigibpy.ContractDetails_notes_get, _swigibpy.ContractDetails_notes_set)
    __swig_destroy__ = _swigibpy.delete_ContractDetails
ContractDetails_swigregister = _swigibpy.ContractDetails_swigregister
ContractDetails_swigregister(ContractDetails)

class EClient(object):
    """Proxy of C++ EClient class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _swigibpy.delete_EClient

    def eConnect(self, host, port, clientId=0, extraAuth=False):
        """eConnect(EClient self, char const * host, unsigned int port, int clientId=0, bool extraAuth=False) -> bool"""
        return _swigibpy.EClient_eConnect(self, host, port, clientId, extraAuth)


    def eDisconnect(self):
        """eDisconnect(EClient self)"""
        return _swigibpy.EClient_eDisconnect(self)


    def serverVersion(self):
        """serverVersion(EClient self) -> int"""
        return _swigibpy.EClient_serverVersion(self)


    def TwsConnectionTime(self):
        """TwsConnectionTime(EClient self) -> IBString"""
        return _swigibpy.EClient_TwsConnectionTime(self)


    def reqMktData(self, id, contract, genericTicks, snapshot, mktDataOptions):
        """reqMktData(EClient self, TickerId id, Contract contract, IBString const & genericTicks, bool snapshot, TagValueListSPtr const & mktDataOptions)"""
        return _swigibpy.EClient_reqMktData(self, id, contract, genericTicks, snapshot, mktDataOptions)


    def cancelMktData(self, id):
        """cancelMktData(EClient self, TickerId id)"""
        return _swigibpy.EClient_cancelMktData(self, id)


    def placeOrder(self, id, contract, order):
        """placeOrder(EClient self, OrderId id, Contract contract, Order order)"""
        return _swigibpy.EClient_placeOrder(self, id, contract, order)


    def cancelOrder(self, id):
        """cancelOrder(EClient self, OrderId id)"""
        return _swigibpy.EClient_cancelOrder(self, id)


    def reqOpenOrders(self):
        """reqOpenOrders(EClient self)"""
        return _swigibpy.EClient_reqOpenOrders(self)


    def reqAccountUpdates(self, subscribe, acctCode):
        """reqAccountUpdates(EClient self, bool subscribe, IBString const & acctCode)"""
        return _swigibpy.EClient_reqAccountUpdates(self, subscribe, acctCode)


    def reqExecutions(self, reqId, filter):
        """reqExecutions(EClient self, int reqId, ExecutionFilter filter)"""
        return _swigibpy.EClient_reqExecutions(self, reqId, filter)


    def reqIds(self, numIds):
        """reqIds(EClient self, int numIds)"""
        return _swigibpy.EClient_reqIds(self, numIds)


    def checkMessages(self):
        """checkMessages(EClient self) -> bool"""
        return _swigibpy.EClient_checkMessages(self)


    def reqContractDetails(self, reqId, contract):
        """reqContractDetails(EClient self, int reqId, Contract contract)"""
        return _swigibpy.EClient_reqContractDetails(self, reqId, contract)


    def reqMktDepth(self, id, contract, numRows, mktDepthOptions):
        """reqMktDepth(EClient self, TickerId id, Contract contract, int numRows, TagValueListSPtr const & mktDepthOptions)"""
        return _swigibpy.EClient_reqMktDepth(self, id, contract, numRows, mktDepthOptions)


    def cancelMktDepth(self, id):
        """cancelMktDepth(EClient self, TickerId id)"""
        return _swigibpy.EClient_cancelMktDepth(self, id)


    def reqNewsBulletins(self, allMsgs):
        """reqNewsBulletins(EClient self, bool allMsgs)"""
        return _swigibpy.EClient_reqNewsBulletins(self, allMsgs)


    def cancelNewsBulletins(self):
        """cancelNewsBulletins(EClient self)"""
        return _swigibpy.EClient_cancelNewsBulletins(self)


    def setServerLogLevel(self, level):
        """setServerLogLevel(EClient self, int level)"""
        return _swigibpy.EClient_setServerLogLevel(self, level)


    def reqAutoOpenOrders(self, bAutoBind):
        """reqAutoOpenOrders(EClient self, bool bAutoBind)"""
        return _swigibpy.EClient_reqAutoOpenOrders(self, bAutoBind)


    def reqAllOpenOrders(self):
        """reqAllOpenOrders(EClient self)"""
        return _swigibpy.EClient_reqAllOpenOrders(self)


    def reqManagedAccts(self):
        """reqManagedAccts(EClient self)"""
        return _swigibpy.EClient_reqManagedAccts(self)


    def requestFA(self, pFaDataType):
        """requestFA(EClient self, faDataType pFaDataType)"""
        return _swigibpy.EClient_requestFA(self, pFaDataType)


    def replaceFA(self, pFaDataType, cxml):
        """replaceFA(EClient self, faDataType pFaDataType, IBString const & cxml)"""
        return _swigibpy.EClient_replaceFA(self, pFaDataType, cxml)


    def reqHistoricalData(self, id, contract, endDateTime, durationStr, barSizeSetting, whatToShow, useRTH, formatDate, chartOptions):
        """reqHistoricalData(EClient self, TickerId id, Contract contract, IBString const & endDateTime, IBString const & durationStr, IBString const & barSizeSetting, IBString const & whatToShow, int useRTH, int formatDate, TagValueListSPtr const & chartOptions)"""
        return _swigibpy.EClient_reqHistoricalData(self, id, contract, endDateTime, durationStr, barSizeSetting, whatToShow, useRTH, formatDate, chartOptions)


    def exerciseOptions(self, id, contract, exerciseAction, exerciseQuantity, account, override):
        """exerciseOptions(EClient self, TickerId id, Contract contract, int exerciseAction, int exerciseQuantity, IBString const & account, int override)"""
        return _swigibpy.EClient_exerciseOptions(self, id, contract, exerciseAction, exerciseQuantity, account, override)


    def cancelHistoricalData(self, tickerId):
        """cancelHistoricalData(EClient self, TickerId tickerId)"""
        return _swigibpy.EClient_cancelHistoricalData(self, tickerId)


    def reqRealTimeBars(self, id, contract, barSize, whatToShow, useRTH, realTimeBarsOptions):
        """reqRealTimeBars(EClient self, TickerId id, Contract contract, int barSize, IBString const & whatToShow, bool useRTH, TagValueListSPtr const & realTimeBarsOptions)"""
        return _swigibpy.EClient_reqRealTimeBars(self, id, contract, barSize, whatToShow, useRTH, realTimeBarsOptions)


    def cancelRealTimeBars(self, tickerId):
        """cancelRealTimeBars(EClient self, TickerId tickerId)"""
        return _swigibpy.EClient_cancelRealTimeBars(self, tickerId)


    def cancelScannerSubscription(self, tickerId):
        """cancelScannerSubscription(EClient self, int tickerId)"""
        return _swigibpy.EClient_cancelScannerSubscription(self, tickerId)


    def reqScannerParameters(self):
        """reqScannerParameters(EClient self)"""
        return _swigibpy.EClient_reqScannerParameters(self)


    def reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions):
        """reqScannerSubscription(EClient self, int tickerId, ScannerSubscription subscription, TagValueListSPtr const & scannerSubscriptionOptions)"""
        return _swigibpy.EClient_reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions)


    def reqCurrentTime(self):
        """reqCurrentTime(EClient self)"""
        return _swigibpy.EClient_reqCurrentTime(self)


    def reqFundamentalData(self, reqId, arg3, reportType):
        """reqFundamentalData(EClient self, TickerId reqId, Contract arg3, IBString const & reportType)"""
        return _swigibpy.EClient_reqFundamentalData(self, reqId, arg3, reportType)


    def cancelFundamentalData(self, reqId):
        """cancelFundamentalData(EClient self, TickerId reqId)"""
        return _swigibpy.EClient_cancelFundamentalData(self, reqId)


    def calculateImpliedVolatility(self, reqId, contract, optionPrice, underPrice):
        """calculateImpliedVolatility(EClient self, TickerId reqId, Contract contract, double optionPrice, double underPrice)"""
        return _swigibpy.EClient_calculateImpliedVolatility(self, reqId, contract, optionPrice, underPrice)


    def calculateOptionPrice(self, reqId, contract, volatility, underPrice):
        """calculateOptionPrice(EClient self, TickerId reqId, Contract contract, double volatility, double underPrice)"""
        return _swigibpy.EClient_calculateOptionPrice(self, reqId, contract, volatility, underPrice)


    def cancelCalculateImpliedVolatility(self, reqId):
        """cancelCalculateImpliedVolatility(EClient self, TickerId reqId)"""
        return _swigibpy.EClient_cancelCalculateImpliedVolatility(self, reqId)


    def cancelCalculateOptionPrice(self, reqId):
        """cancelCalculateOptionPrice(EClient self, TickerId reqId)"""
        return _swigibpy.EClient_cancelCalculateOptionPrice(self, reqId)


    def reqGlobalCancel(self):
        """reqGlobalCancel(EClient self)"""
        return _swigibpy.EClient_reqGlobalCancel(self)


    def reqMarketDataType(self, marketDataType):
        """reqMarketDataType(EClient self, int marketDataType)"""
        return _swigibpy.EClient_reqMarketDataType(self, marketDataType)


    def reqPositions(self):
        """reqPositions(EClient self)"""
        return _swigibpy.EClient_reqPositions(self)


    def cancelPositions(self):
        """cancelPositions(EClient self)"""
        return _swigibpy.EClient_cancelPositions(self)


    def reqAccountSummary(self, reqId, groupName, tags):
        """reqAccountSummary(EClient self, int reqId, IBString const & groupName, IBString const & tags)"""
        return _swigibpy.EClient_reqAccountSummary(self, reqId, groupName, tags)


    def cancelAccountSummary(self, reqId):
        """cancelAccountSummary(EClient self, int reqId)"""
        return _swigibpy.EClient_cancelAccountSummary(self, reqId)


    def verifyRequest(self, apiName, apiVersion):
        """verifyRequest(EClient self, IBString const & apiName, IBString const & apiVersion)"""
        return _swigibpy.EClient_verifyRequest(self, apiName, apiVersion)


    def verifyMessage(self, apiData):
        """verifyMessage(EClient self, IBString const & apiData)"""
        return _swigibpy.EClient_verifyMessage(self, apiData)


    def queryDisplayGroups(self, reqId):
        """queryDisplayGroups(EClient self, int reqId)"""
        return _swigibpy.EClient_queryDisplayGroups(self, reqId)


    def subscribeToGroupEvents(self, reqId, groupId):
        """subscribeToGroupEvents(EClient self, int reqId, int groupId)"""
        return _swigibpy.EClient_subscribeToGroupEvents(self, reqId, groupId)


    def updateDisplayGroup(self, reqId, contractInfo):
        """updateDisplayGroup(EClient self, int reqId, IBString const & contractInfo)"""
        return _swigibpy.EClient_updateDisplayGroup(self, reqId, contractInfo)


    def unsubscribeFromGroupEvents(self, reqId):
        """unsubscribeFromGroupEvents(EClient self, int reqId)"""
        return _swigibpy.EClient_unsubscribeFromGroupEvents(self, reqId)

EClient.eConnect = new_instancemethod(_swigibpy.EClient_eConnect, None, EClient)
EClient.eDisconnect = new_instancemethod(_swigibpy.EClient_eDisconnect, None, EClient)
EClient.serverVersion = new_instancemethod(_swigibpy.EClient_serverVersion, None, EClient)
EClient.TwsConnectionTime = new_instancemethod(_swigibpy.EClient_TwsConnectionTime, None, EClient)
EClient.reqMktData = new_instancemethod(_swigibpy.EClient_reqMktData, None, EClient)
EClient.cancelMktData = new_instancemethod(_swigibpy.EClient_cancelMktData, None, EClient)
EClient.placeOrder = new_instancemethod(_swigibpy.EClient_placeOrder, None, EClient)
EClient.cancelOrder = new_instancemethod(_swigibpy.EClient_cancelOrder, None, EClient)
EClient.reqOpenOrders = new_instancemethod(_swigibpy.EClient_reqOpenOrders, None, EClient)
EClient.reqAccountUpdates = new_instancemethod(_swigibpy.EClient_reqAccountUpdates, None, EClient)
EClient.reqExecutions = new_instancemethod(_swigibpy.EClient_reqExecutions, None, EClient)
EClient.reqIds = new_instancemethod(_swigibpy.EClient_reqIds, None, EClient)
EClient.checkMessages = new_instancemethod(_swigibpy.EClient_checkMessages, None, EClient)
EClient.reqContractDetails = new_instancemethod(_swigibpy.EClient_reqContractDetails, None, EClient)
EClient.reqMktDepth = new_instancemethod(_swigibpy.EClient_reqMktDepth, None, EClient)
EClient.cancelMktDepth = new_instancemethod(_swigibpy.EClient_cancelMktDepth, None, EClient)
EClient.reqNewsBulletins = new_instancemethod(_swigibpy.EClient_reqNewsBulletins, None, EClient)
EClient.cancelNewsBulletins = new_instancemethod(_swigibpy.EClient_cancelNewsBulletins, None, EClient)
EClient.setServerLogLevel = new_instancemethod(_swigibpy.EClient_setServerLogLevel, None, EClient)
EClient.reqAutoOpenOrders = new_instancemethod(_swigibpy.EClient_reqAutoOpenOrders, None, EClient)
EClient.reqAllOpenOrders = new_instancemethod(_swigibpy.EClient_reqAllOpenOrders, None, EClient)
EClient.reqManagedAccts = new_instancemethod(_swigibpy.EClient_reqManagedAccts, None, EClient)
EClient.requestFA = new_instancemethod(_swigibpy.EClient_requestFA, None, EClient)
EClient.replaceFA = new_instancemethod(_swigibpy.EClient_replaceFA, None, EClient)
EClient.reqHistoricalData = new_instancemethod(_swigibpy.EClient_reqHistoricalData, None, EClient)
EClient.exerciseOptions = new_instancemethod(_swigibpy.EClient_exerciseOptions, None, EClient)
EClient.cancelHistoricalData = new_instancemethod(_swigibpy.EClient_cancelHistoricalData, None, EClient)
EClient.reqRealTimeBars = new_instancemethod(_swigibpy.EClient_reqRealTimeBars, None, EClient)
EClient.cancelRealTimeBars = new_instancemethod(_swigibpy.EClient_cancelRealTimeBars, None, EClient)
EClient.cancelScannerSubscription = new_instancemethod(_swigibpy.EClient_cancelScannerSubscription, None, EClient)
EClient.reqScannerParameters = new_instancemethod(_swigibpy.EClient_reqScannerParameters, None, EClient)
EClient.reqScannerSubscription = new_instancemethod(_swigibpy.EClient_reqScannerSubscription, None, EClient)
EClient.reqCurrentTime = new_instancemethod(_swigibpy.EClient_reqCurrentTime, None, EClient)
EClient.reqFundamentalData = new_instancemethod(_swigibpy.EClient_reqFundamentalData, None, EClient)
EClient.cancelFundamentalData = new_instancemethod(_swigibpy.EClient_cancelFundamentalData, None, EClient)
EClient.calculateImpliedVolatility = new_instancemethod(_swigibpy.EClient_calculateImpliedVolatility, None, EClient)
EClient.calculateOptionPrice = new_instancemethod(_swigibpy.EClient_calculateOptionPrice, None, EClient)
EClient.cancelCalculateImpliedVolatility = new_instancemethod(_swigibpy.EClient_cancelCalculateImpliedVolatility, None, EClient)
EClient.cancelCalculateOptionPrice = new_instancemethod(_swigibpy.EClient_cancelCalculateOptionPrice, None, EClient)
EClient.reqGlobalCancel = new_instancemethod(_swigibpy.EClient_reqGlobalCancel, None, EClient)
EClient.reqMarketDataType = new_instancemethod(_swigibpy.EClient_reqMarketDataType, None, EClient)
EClient.reqPositions = new_instancemethod(_swigibpy.EClient_reqPositions, None, EClient)
EClient.cancelPositions = new_instancemethod(_swigibpy.EClient_cancelPositions, None, EClient)
EClient.reqAccountSummary = new_instancemethod(_swigibpy.EClient_reqAccountSummary, None, EClient)
EClient.cancelAccountSummary = new_instancemethod(_swigibpy.EClient_cancelAccountSummary, None, EClient)
EClient.verifyRequest = new_instancemethod(_swigibpy.EClient_verifyRequest, None, EClient)
EClient.verifyMessage = new_instancemethod(_swigibpy.EClient_verifyMessage, None, EClient)
EClient.queryDisplayGroups = new_instancemethod(_swigibpy.EClient_queryDisplayGroups, None, EClient)
EClient.subscribeToGroupEvents = new_instancemethod(_swigibpy.EClient_subscribeToGroupEvents, None, EClient)
EClient.updateDisplayGroup = new_instancemethod(_swigibpy.EClient_updateDisplayGroup, None, EClient)
EClient.unsubscribeFromGroupEvents = new_instancemethod(_swigibpy.EClient_unsubscribeFromGroupEvents, None, EClient)
EClient_swigregister = _swigibpy.EClient_swigregister
EClient_swigregister(EClient)

class EClientSocketBase(EClient):
    """Proxy of C++ EClientSocketBase class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _swigibpy.delete_EClientSocketBase

    def eConnect(self, host, port, clientId=0, extraAuth=False):
        """eConnect(EClientSocketBase self, char const * host, unsigned int port, int clientId=0, bool extraAuth=False) -> bool"""
        return _swigibpy.EClientSocketBase_eConnect(self, host, port, clientId, extraAuth)


    def eDisconnect(self):
        """eDisconnect(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_eDisconnect(self)


    def clientId(self):
        """clientId(EClientSocketBase self) -> int"""
        return _swigibpy.EClientSocketBase_clientId(self)


    def isConnected(self):
        """isConnected(EClientSocketBase self) -> bool"""
        return _swigibpy.EClientSocketBase_isConnected(self)


    def isInBufferEmpty(self):
        """isInBufferEmpty(EClientSocketBase self) -> bool"""
        return _swigibpy.EClientSocketBase_isInBufferEmpty(self)


    def isOutBufferEmpty(self):
        """isOutBufferEmpty(EClientSocketBase self) -> bool"""
        return _swigibpy.EClientSocketBase_isOutBufferEmpty(self)


    def serverVersion(self):
        """serverVersion(EClientSocketBase self) -> int"""
        return _swigibpy.EClientSocketBase_serverVersion(self)


    def TwsConnectionTime(self):
        """TwsConnectionTime(EClientSocketBase self) -> IBString"""
        return _swigibpy.EClientSocketBase_TwsConnectionTime(self)


    def reqMktData(self, id, contract, genericTicks, snapshot, mktDataOptions):
        """reqMktData(EClientSocketBase self, TickerId id, Contract contract, IBString const & genericTicks, bool snapshot, TagValueListSPtr const & mktDataOptions)"""
        return _swigibpy.EClientSocketBase_reqMktData(self, id, contract, genericTicks, snapshot, mktDataOptions)


    def cancelMktData(self, id):
        """cancelMktData(EClientSocketBase self, TickerId id)"""
        return _swigibpy.EClientSocketBase_cancelMktData(self, id)


    def placeOrder(self, id, contract, order):
        """placeOrder(EClientSocketBase self, OrderId id, Contract contract, Order order)"""
        return _swigibpy.EClientSocketBase_placeOrder(self, id, contract, order)


    def cancelOrder(self, id):
        """cancelOrder(EClientSocketBase self, OrderId id)"""
        return _swigibpy.EClientSocketBase_cancelOrder(self, id)


    def reqOpenOrders(self):
        """reqOpenOrders(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqOpenOrders(self)


    def reqAccountUpdates(self, subscribe, acctCode):
        """reqAccountUpdates(EClientSocketBase self, bool subscribe, IBString const & acctCode)"""
        return _swigibpy.EClientSocketBase_reqAccountUpdates(self, subscribe, acctCode)


    def reqExecutions(self, reqId, filter):
        """reqExecutions(EClientSocketBase self, int reqId, ExecutionFilter filter)"""
        return _swigibpy.EClientSocketBase_reqExecutions(self, reqId, filter)


    def reqIds(self, numIds):
        """reqIds(EClientSocketBase self, int numIds)"""
        return _swigibpy.EClientSocketBase_reqIds(self, numIds)


    def checkMessages(self):
        """checkMessages(EClientSocketBase self) -> bool"""
        return _swigibpy.EClientSocketBase_checkMessages(self)


    def reqContractDetails(self, reqId, contract):
        """reqContractDetails(EClientSocketBase self, int reqId, Contract contract)"""
        return _swigibpy.EClientSocketBase_reqContractDetails(self, reqId, contract)


    def reqMktDepth(self, tickerId, contract, numRows, mktDepthOptions):
        """reqMktDepth(EClientSocketBase self, TickerId tickerId, Contract contract, int numRows, TagValueListSPtr const & mktDepthOptions)"""
        return _swigibpy.EClientSocketBase_reqMktDepth(self, tickerId, contract, numRows, mktDepthOptions)


    def cancelMktDepth(self, tickerId):
        """cancelMktDepth(EClientSocketBase self, TickerId tickerId)"""
        return _swigibpy.EClientSocketBase_cancelMktDepth(self, tickerId)


    def reqNewsBulletins(self, allMsgs):
        """reqNewsBulletins(EClientSocketBase self, bool allMsgs)"""
        return _swigibpy.EClientSocketBase_reqNewsBulletins(self, allMsgs)


    def cancelNewsBulletins(self):
        """cancelNewsBulletins(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_cancelNewsBulletins(self)


    def setServerLogLevel(self, level):
        """setServerLogLevel(EClientSocketBase self, int level)"""
        return _swigibpy.EClientSocketBase_setServerLogLevel(self, level)


    def reqAutoOpenOrders(self, bAutoBind):
        """reqAutoOpenOrders(EClientSocketBase self, bool bAutoBind)"""
        return _swigibpy.EClientSocketBase_reqAutoOpenOrders(self, bAutoBind)


    def reqAllOpenOrders(self):
        """reqAllOpenOrders(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqAllOpenOrders(self)


    def reqManagedAccts(self):
        """reqManagedAccts(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqManagedAccts(self)


    def requestFA(self, pFaDataType):
        """requestFA(EClientSocketBase self, faDataType pFaDataType)"""
        return _swigibpy.EClientSocketBase_requestFA(self, pFaDataType)


    def replaceFA(self, pFaDataType, cxml):
        """replaceFA(EClientSocketBase self, faDataType pFaDataType, IBString const & cxml)"""
        return _swigibpy.EClientSocketBase_replaceFA(self, pFaDataType, cxml)


    def reqHistoricalData(self, id, contract, endDateTime, durationStr, barSizeSetting, whatToShow, useRTH, formatDate, chartOptions):
        """reqHistoricalData(EClientSocketBase self, TickerId id, Contract contract, IBString const & endDateTime, IBString const & durationStr, IBString const & barSizeSetting, IBString const & whatToShow, int useRTH, int formatDate, TagValueListSPtr const & chartOptions)"""
        return _swigibpy.EClientSocketBase_reqHistoricalData(self, id, contract, endDateTime, durationStr, barSizeSetting, whatToShow, useRTH, formatDate, chartOptions)


    def exerciseOptions(self, tickerId, contract, exerciseAction, exerciseQuantity, account, override):
        """exerciseOptions(EClientSocketBase self, TickerId tickerId, Contract contract, int exerciseAction, int exerciseQuantity, IBString const & account, int override)"""
        return _swigibpy.EClientSocketBase_exerciseOptions(self, tickerId, contract, exerciseAction, exerciseQuantity, account, override)


    def cancelHistoricalData(self, tickerId):
        """cancelHistoricalData(EClientSocketBase self, TickerId tickerId)"""
        return _swigibpy.EClientSocketBase_cancelHistoricalData(self, tickerId)


    def reqRealTimeBars(self, id, contract, barSize, whatToShow, useRTH, realTimeBarsOptions):
        """reqRealTimeBars(EClientSocketBase self, TickerId id, Contract contract, int barSize, IBString const & whatToShow, bool useRTH, TagValueListSPtr const & realTimeBarsOptions)"""
        return _swigibpy.EClientSocketBase_reqRealTimeBars(self, id, contract, barSize, whatToShow, useRTH, realTimeBarsOptions)


    def cancelRealTimeBars(self, tickerId):
        """cancelRealTimeBars(EClientSocketBase self, TickerId tickerId)"""
        return _swigibpy.EClientSocketBase_cancelRealTimeBars(self, tickerId)


    def cancelScannerSubscription(self, tickerId):
        """cancelScannerSubscription(EClientSocketBase self, int tickerId)"""
        return _swigibpy.EClientSocketBase_cancelScannerSubscription(self, tickerId)


    def reqScannerParameters(self):
        """reqScannerParameters(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqScannerParameters(self)


    def reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions):
        """reqScannerSubscription(EClientSocketBase self, int tickerId, ScannerSubscription subscription, TagValueListSPtr const & scannerSubscriptionOptions)"""
        return _swigibpy.EClientSocketBase_reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions)


    def reqCurrentTime(self):
        """reqCurrentTime(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqCurrentTime(self)


    def reqFundamentalData(self, reqId, arg3, reportType):
        """reqFundamentalData(EClientSocketBase self, TickerId reqId, Contract arg3, IBString const & reportType)"""
        return _swigibpy.EClientSocketBase_reqFundamentalData(self, reqId, arg3, reportType)


    def cancelFundamentalData(self, reqId):
        """cancelFundamentalData(EClientSocketBase self, TickerId reqId)"""
        return _swigibpy.EClientSocketBase_cancelFundamentalData(self, reqId)


    def calculateImpliedVolatility(self, reqId, contract, optionPrice, underPrice):
        """calculateImpliedVolatility(EClientSocketBase self, TickerId reqId, Contract contract, double optionPrice, double underPrice)"""
        return _swigibpy.EClientSocketBase_calculateImpliedVolatility(self, reqId, contract, optionPrice, underPrice)


    def calculateOptionPrice(self, reqId, contract, volatility, underPrice):
        """calculateOptionPrice(EClientSocketBase self, TickerId reqId, Contract contract, double volatility, double underPrice)"""
        return _swigibpy.EClientSocketBase_calculateOptionPrice(self, reqId, contract, volatility, underPrice)


    def cancelCalculateImpliedVolatility(self, reqId):
        """cancelCalculateImpliedVolatility(EClientSocketBase self, TickerId reqId)"""
        return _swigibpy.EClientSocketBase_cancelCalculateImpliedVolatility(self, reqId)


    def cancelCalculateOptionPrice(self, reqId):
        """cancelCalculateOptionPrice(EClientSocketBase self, TickerId reqId)"""
        return _swigibpy.EClientSocketBase_cancelCalculateOptionPrice(self, reqId)


    def reqGlobalCancel(self):
        """reqGlobalCancel(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqGlobalCancel(self)


    def reqMarketDataType(self, marketDataType):
        """reqMarketDataType(EClientSocketBase self, int marketDataType)"""
        return _swigibpy.EClientSocketBase_reqMarketDataType(self, marketDataType)


    def reqPositions(self):
        """reqPositions(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_reqPositions(self)


    def cancelPositions(self):
        """cancelPositions(EClientSocketBase self)"""
        return _swigibpy.EClientSocketBase_cancelPositions(self)


    def reqAccountSummary(self, reqId, groupName, tags):
        """reqAccountSummary(EClientSocketBase self, int reqId, IBString const & groupName, IBString const & tags)"""
        return _swigibpy.EClientSocketBase_reqAccountSummary(self, reqId, groupName, tags)


    def cancelAccountSummary(self, reqId):
        """cancelAccountSummary(EClientSocketBase self, int reqId)"""
        return _swigibpy.EClientSocketBase_cancelAccountSummary(self, reqId)


    def verifyRequest(self, apiName, apiVersion):
        """verifyRequest(EClientSocketBase self, IBString const & apiName, IBString const & apiVersion)"""
        return _swigibpy.EClientSocketBase_verifyRequest(self, apiName, apiVersion)


    def verifyMessage(self, apiData):
        """verifyMessage(EClientSocketBase self, IBString const & apiData)"""
        return _swigibpy.EClientSocketBase_verifyMessage(self, apiData)


    def queryDisplayGroups(self, reqId):
        """queryDisplayGroups(EClientSocketBase self, int reqId)"""
        return _swigibpy.EClientSocketBase_queryDisplayGroups(self, reqId)


    def subscribeToGroupEvents(self, reqId, groupId):
        """subscribeToGroupEvents(EClientSocketBase self, int reqId, int groupId)"""
        return _swigibpy.EClientSocketBase_subscribeToGroupEvents(self, reqId, groupId)


    def updateDisplayGroup(self, reqId, contractInfo):
        """updateDisplayGroup(EClientSocketBase self, int reqId, IBString const & contractInfo)"""
        return _swigibpy.EClientSocketBase_updateDisplayGroup(self, reqId, contractInfo)


    def unsubscribeFromGroupEvents(self, reqId):
        """unsubscribeFromGroupEvents(EClientSocketBase self, int reqId)"""
        return _swigibpy.EClientSocketBase_unsubscribeFromGroupEvents(self, reqId)

EClientSocketBase.eConnect = new_instancemethod(_swigibpy.EClientSocketBase_eConnect, None, EClientSocketBase)
EClientSocketBase.eDisconnect = new_instancemethod(_swigibpy.EClientSocketBase_eDisconnect, None, EClientSocketBase)
EClientSocketBase.clientId = new_instancemethod(_swigibpy.EClientSocketBase_clientId, None, EClientSocketBase)
EClientSocketBase.isConnected = new_instancemethod(_swigibpy.EClientSocketBase_isConnected, None, EClientSocketBase)
EClientSocketBase.isInBufferEmpty = new_instancemethod(_swigibpy.EClientSocketBase_isInBufferEmpty, None, EClientSocketBase)
EClientSocketBase.isOutBufferEmpty = new_instancemethod(_swigibpy.EClientSocketBase_isOutBufferEmpty, None, EClientSocketBase)
EClientSocketBase.serverVersion = new_instancemethod(_swigibpy.EClientSocketBase_serverVersion, None, EClientSocketBase)
EClientSocketBase.TwsConnectionTime = new_instancemethod(_swigibpy.EClientSocketBase_TwsConnectionTime, None, EClientSocketBase)
EClientSocketBase.reqMktData = new_instancemethod(_swigibpy.EClientSocketBase_reqMktData, None, EClientSocketBase)
EClientSocketBase.cancelMktData = new_instancemethod(_swigibpy.EClientSocketBase_cancelMktData, None, EClientSocketBase)
EClientSocketBase.placeOrder = new_instancemethod(_swigibpy.EClientSocketBase_placeOrder, None, EClientSocketBase)
EClientSocketBase.cancelOrder = new_instancemethod(_swigibpy.EClientSocketBase_cancelOrder, None, EClientSocketBase)
EClientSocketBase.reqOpenOrders = new_instancemethod(_swigibpy.EClientSocketBase_reqOpenOrders, None, EClientSocketBase)
EClientSocketBase.reqAccountUpdates = new_instancemethod(_swigibpy.EClientSocketBase_reqAccountUpdates, None, EClientSocketBase)
EClientSocketBase.reqExecutions = new_instancemethod(_swigibpy.EClientSocketBase_reqExecutions, None, EClientSocketBase)
EClientSocketBase.reqIds = new_instancemethod(_swigibpy.EClientSocketBase_reqIds, None, EClientSocketBase)
EClientSocketBase.checkMessages = new_instancemethod(_swigibpy.EClientSocketBase_checkMessages, None, EClientSocketBase)
EClientSocketBase.reqContractDetails = new_instancemethod(_swigibpy.EClientSocketBase_reqContractDetails, None, EClientSocketBase)
EClientSocketBase.reqMktDepth = new_instancemethod(_swigibpy.EClientSocketBase_reqMktDepth, None, EClientSocketBase)
EClientSocketBase.cancelMktDepth = new_instancemethod(_swigibpy.EClientSocketBase_cancelMktDepth, None, EClientSocketBase)
EClientSocketBase.reqNewsBulletins = new_instancemethod(_swigibpy.EClientSocketBase_reqNewsBulletins, None, EClientSocketBase)
EClientSocketBase.cancelNewsBulletins = new_instancemethod(_swigibpy.EClientSocketBase_cancelNewsBulletins, None, EClientSocketBase)
EClientSocketBase.setServerLogLevel = new_instancemethod(_swigibpy.EClientSocketBase_setServerLogLevel, None, EClientSocketBase)
EClientSocketBase.reqAutoOpenOrders = new_instancemethod(_swigibpy.EClientSocketBase_reqAutoOpenOrders, None, EClientSocketBase)
EClientSocketBase.reqAllOpenOrders = new_instancemethod(_swigibpy.EClientSocketBase_reqAllOpenOrders, None, EClientSocketBase)
EClientSocketBase.reqManagedAccts = new_instancemethod(_swigibpy.EClientSocketBase_reqManagedAccts, None, EClientSocketBase)
EClientSocketBase.requestFA = new_instancemethod(_swigibpy.EClientSocketBase_requestFA, None, EClientSocketBase)
EClientSocketBase.replaceFA = new_instancemethod(_swigibpy.EClientSocketBase_replaceFA, None, EClientSocketBase)
EClientSocketBase.reqHistoricalData = new_instancemethod(_swigibpy.EClientSocketBase_reqHistoricalData, None, EClientSocketBase)
EClientSocketBase.exerciseOptions = new_instancemethod(_swigibpy.EClientSocketBase_exerciseOptions, None, EClientSocketBase)
EClientSocketBase.cancelHistoricalData = new_instancemethod(_swigibpy.EClientSocketBase_cancelHistoricalData, None, EClientSocketBase)
EClientSocketBase.reqRealTimeBars = new_instancemethod(_swigibpy.EClientSocketBase_reqRealTimeBars, None, EClientSocketBase)
EClientSocketBase.cancelRealTimeBars = new_instancemethod(_swigibpy.EClientSocketBase_cancelRealTimeBars, None, EClientSocketBase)
EClientSocketBase.cancelScannerSubscription = new_instancemethod(_swigibpy.EClientSocketBase_cancelScannerSubscription, None, EClientSocketBase)
EClientSocketBase.reqScannerParameters = new_instancemethod(_swigibpy.EClientSocketBase_reqScannerParameters, None, EClientSocketBase)
EClientSocketBase.reqScannerSubscription = new_instancemethod(_swigibpy.EClientSocketBase_reqScannerSubscription, None, EClientSocketBase)
EClientSocketBase.reqCurrentTime = new_instancemethod(_swigibpy.EClientSocketBase_reqCurrentTime, None, EClientSocketBase)
EClientSocketBase.reqFundamentalData = new_instancemethod(_swigibpy.EClientSocketBase_reqFundamentalData, None, EClientSocketBase)
EClientSocketBase.cancelFundamentalData = new_instancemethod(_swigibpy.EClientSocketBase_cancelFundamentalData, None, EClientSocketBase)
EClientSocketBase.calculateImpliedVolatility = new_instancemethod(_swigibpy.EClientSocketBase_calculateImpliedVolatility, None, EClientSocketBase)
EClientSocketBase.calculateOptionPrice = new_instancemethod(_swigibpy.EClientSocketBase_calculateOptionPrice, None, EClientSocketBase)
EClientSocketBase.cancelCalculateImpliedVolatility = new_instancemethod(_swigibpy.EClientSocketBase_cancelCalculateImpliedVolatility, None, EClientSocketBase)
EClientSocketBase.cancelCalculateOptionPrice = new_instancemethod(_swigibpy.EClientSocketBase_cancelCalculateOptionPrice, None, EClientSocketBase)
EClientSocketBase.reqGlobalCancel = new_instancemethod(_swigibpy.EClientSocketBase_reqGlobalCancel, None, EClientSocketBase)
EClientSocketBase.reqMarketDataType = new_instancemethod(_swigibpy.EClientSocketBase_reqMarketDataType, None, EClientSocketBase)
EClientSocketBase.reqPositions = new_instancemethod(_swigibpy.EClientSocketBase_reqPositions, None, EClientSocketBase)
EClientSocketBase.cancelPositions = new_instancemethod(_swigibpy.EClientSocketBase_cancelPositions, None, EClientSocketBase)
EClientSocketBase.reqAccountSummary = new_instancemethod(_swigibpy.EClientSocketBase_reqAccountSummary, None, EClientSocketBase)
EClientSocketBase.cancelAccountSummary = new_instancemethod(_swigibpy.EClientSocketBase_cancelAccountSummary, None, EClientSocketBase)
EClientSocketBase.verifyRequest = new_instancemethod(_swigibpy.EClientSocketBase_verifyRequest, None, EClientSocketBase)
EClientSocketBase.verifyMessage = new_instancemethod(_swigibpy.EClientSocketBase_verifyMessage, None, EClientSocketBase)
EClientSocketBase.queryDisplayGroups = new_instancemethod(_swigibpy.EClientSocketBase_queryDisplayGroups, None, EClientSocketBase)
EClientSocketBase.subscribeToGroupEvents = new_instancemethod(_swigibpy.EClientSocketBase_subscribeToGroupEvents, None, EClientSocketBase)
EClientSocketBase.updateDisplayGroup = new_instancemethod(_swigibpy.EClientSocketBase_updateDisplayGroup, None, EClientSocketBase)
EClientSocketBase.unsubscribeFromGroupEvents = new_instancemethod(_swigibpy.EClientSocketBase_unsubscribeFromGroupEvents, None, EClientSocketBase)
EClientSocketBase_swigregister = _swigibpy.EClientSocketBase_swigregister
EClientSocketBase_swigregister(EClientSocketBase)

class Execution(object):
    """Proxy of C++ Execution class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(Execution self) -> Execution"""
        _swigibpy.Execution_swiginit(self, _swigibpy.new_Execution())
    execId = _swig_property(_swigibpy.Execution_execId_get, _swigibpy.Execution_execId_set)
    time = _swig_property(_swigibpy.Execution_time_get, _swigibpy.Execution_time_set)
    acctNumber = _swig_property(_swigibpy.Execution_acctNumber_get, _swigibpy.Execution_acctNumber_set)
    exchange = _swig_property(_swigibpy.Execution_exchange_get, _swigibpy.Execution_exchange_set)
    side = _swig_property(_swigibpy.Execution_side_get, _swigibpy.Execution_side_set)
    shares = _swig_property(_swigibpy.Execution_shares_get, _swigibpy.Execution_shares_set)
    price = _swig_property(_swigibpy.Execution_price_get, _swigibpy.Execution_price_set)
    permId = _swig_property(_swigibpy.Execution_permId_get, _swigibpy.Execution_permId_set)
    clientId = _swig_property(_swigibpy.Execution_clientId_get, _swigibpy.Execution_clientId_set)
    orderId = _swig_property(_swigibpy.Execution_orderId_get, _swigibpy.Execution_orderId_set)
    liquidation = _swig_property(_swigibpy.Execution_liquidation_get, _swigibpy.Execution_liquidation_set)
    cumQty = _swig_property(_swigibpy.Execution_cumQty_get, _swigibpy.Execution_cumQty_set)
    avgPrice = _swig_property(_swigibpy.Execution_avgPrice_get, _swigibpy.Execution_avgPrice_set)
    orderRef = _swig_property(_swigibpy.Execution_orderRef_get, _swigibpy.Execution_orderRef_set)
    evRule = _swig_property(_swigibpy.Execution_evRule_get, _swigibpy.Execution_evRule_set)
    evMultiplier = _swig_property(_swigibpy.Execution_evMultiplier_get, _swigibpy.Execution_evMultiplier_set)
    __swig_destroy__ = _swigibpy.delete_Execution
Execution_swigregister = _swigibpy.Execution_swigregister
Execution_swigregister(Execution)

class ExecutionFilter(object):
    """Proxy of C++ ExecutionFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ExecutionFilter self) -> ExecutionFilter"""
        _swigibpy.ExecutionFilter_swiginit(self, _swigibpy.new_ExecutionFilter())
    m_clientId = _swig_property(_swigibpy.ExecutionFilter_m_clientId_get, _swigibpy.ExecutionFilter_m_clientId_set)
    m_acctCode = _swig_property(_swigibpy.ExecutionFilter_m_acctCode_get, _swigibpy.ExecutionFilter_m_acctCode_set)
    m_time = _swig_property(_swigibpy.ExecutionFilter_m_time_get, _swigibpy.ExecutionFilter_m_time_set)
    m_symbol = _swig_property(_swigibpy.ExecutionFilter_m_symbol_get, _swigibpy.ExecutionFilter_m_symbol_set)
    m_secType = _swig_property(_swigibpy.ExecutionFilter_m_secType_get, _swigibpy.ExecutionFilter_m_secType_set)
    m_exchange = _swig_property(_swigibpy.ExecutionFilter_m_exchange_get, _swigibpy.ExecutionFilter_m_exchange_set)
    m_side = _swig_property(_swigibpy.ExecutionFilter_m_side_get, _swigibpy.ExecutionFilter_m_side_set)
    __swig_destroy__ = _swigibpy.delete_ExecutionFilter
ExecutionFilter_swigregister = _swigibpy.ExecutionFilter_swigregister
ExecutionFilter_swigregister(ExecutionFilter)


_swigibpy.CUSTOMER_swigconstant(_swigibpy)
CUSTOMER = _swigibpy.CUSTOMER

_swigibpy.FIRM_swigconstant(_swigibpy)
FIRM = _swigibpy.FIRM

_swigibpy.UNKNOWN_swigconstant(_swigibpy)
UNKNOWN = _swigibpy.UNKNOWN

_swigibpy.AUCTION_UNSET_swigconstant(_swigibpy)
AUCTION_UNSET = _swigibpy.AUCTION_UNSET

_swigibpy.AUCTION_MATCH_swigconstant(_swigibpy)
AUCTION_MATCH = _swigibpy.AUCTION_MATCH

_swigibpy.AUCTION_IMPROVEMENT_swigconstant(_swigibpy)
AUCTION_IMPROVEMENT = _swigibpy.AUCTION_IMPROVEMENT

_swigibpy.AUCTION_TRANSPARENT_swigconstant(_swigibpy)
AUCTION_TRANSPARENT = _swigibpy.AUCTION_TRANSPARENT
class OrderComboLeg(object):
    """Proxy of C++ OrderComboLeg class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(OrderComboLeg self) -> OrderComboLeg"""
        _swigibpy.OrderComboLeg_swiginit(self, _swigibpy.new_OrderComboLeg())
    price = _swig_property(_swigibpy.OrderComboLeg_price_get, _swigibpy.OrderComboLeg_price_set)

    def __eq__(self, other):
        """__eq__(OrderComboLeg self, OrderComboLeg other) -> bool"""
        return _swigibpy.OrderComboLeg___eq__(self, other)

    __swig_destroy__ = _swigibpy.delete_OrderComboLeg
OrderComboLeg.__eq__ = new_instancemethod(_swigibpy.OrderComboLeg___eq__, None, OrderComboLeg)
OrderComboLeg_swigregister = _swigibpy.OrderComboLeg_swigregister
OrderComboLeg_swigregister(OrderComboLeg)

class Order(object):
    """Proxy of C++ Order class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(Order self) -> Order"""
        _swigibpy.Order_swiginit(self, _swigibpy.new_Order())
    orderId = _swig_property(_swigibpy.Order_orderId_get, _swigibpy.Order_orderId_set)
    clientId = _swig_property(_swigibpy.Order_clientId_get, _swigibpy.Order_clientId_set)
    permId = _swig_property(_swigibpy.Order_permId_get, _swigibpy.Order_permId_set)
    action = _swig_property(_swigibpy.Order_action_get, _swigibpy.Order_action_set)
    totalQuantity = _swig_property(_swigibpy.Order_totalQuantity_get, _swigibpy.Order_totalQuantity_set)
    orderType = _swig_property(_swigibpy.Order_orderType_get, _swigibpy.Order_orderType_set)
    lmtPrice = _swig_property(_swigibpy.Order_lmtPrice_get, _swigibpy.Order_lmtPrice_set)
    auxPrice = _swig_property(_swigibpy.Order_auxPrice_get, _swigibpy.Order_auxPrice_set)
    tif = _swig_property(_swigibpy.Order_tif_get, _swigibpy.Order_tif_set)
    activeStartTime = _swig_property(_swigibpy.Order_activeStartTime_get, _swigibpy.Order_activeStartTime_set)
    activeStopTime = _swig_property(_swigibpy.Order_activeStopTime_get, _swigibpy.Order_activeStopTime_set)
    ocaGroup = _swig_property(_swigibpy.Order_ocaGroup_get, _swigibpy.Order_ocaGroup_set)
    ocaType = _swig_property(_swigibpy.Order_ocaType_get, _swigibpy.Order_ocaType_set)
    orderRef = _swig_property(_swigibpy.Order_orderRef_get, _swigibpy.Order_orderRef_set)
    transmit = _swig_property(_swigibpy.Order_transmit_get, _swigibpy.Order_transmit_set)
    parentId = _swig_property(_swigibpy.Order_parentId_get, _swigibpy.Order_parentId_set)
    blockOrder = _swig_property(_swigibpy.Order_blockOrder_get, _swigibpy.Order_blockOrder_set)
    sweepToFill = _swig_property(_swigibpy.Order_sweepToFill_get, _swigibpy.Order_sweepToFill_set)
    displaySize = _swig_property(_swigibpy.Order_displaySize_get, _swigibpy.Order_displaySize_set)
    triggerMethod = _swig_property(_swigibpy.Order_triggerMethod_get, _swigibpy.Order_triggerMethod_set)
    outsideRth = _swig_property(_swigibpy.Order_outsideRth_get, _swigibpy.Order_outsideRth_set)
    hidden = _swig_property(_swigibpy.Order_hidden_get, _swigibpy.Order_hidden_set)
    goodAfterTime = _swig_property(_swigibpy.Order_goodAfterTime_get, _swigibpy.Order_goodAfterTime_set)
    goodTillDate = _swig_property(_swigibpy.Order_goodTillDate_get, _swigibpy.Order_goodTillDate_set)
    rule80A = _swig_property(_swigibpy.Order_rule80A_get, _swigibpy.Order_rule80A_set)
    allOrNone = _swig_property(_swigibpy.Order_allOrNone_get, _swigibpy.Order_allOrNone_set)
    minQty = _swig_property(_swigibpy.Order_minQty_get, _swigibpy.Order_minQty_set)
    percentOffset = _swig_property(_swigibpy.Order_percentOffset_get, _swigibpy.Order_percentOffset_set)
    overridePercentageConstraints = _swig_property(_swigibpy.Order_overridePercentageConstraints_get, _swigibpy.Order_overridePercentageConstraints_set)
    trailStopPrice = _swig_property(_swigibpy.Order_trailStopPrice_get, _swigibpy.Order_trailStopPrice_set)
    trailingPercent = _swig_property(_swigibpy.Order_trailingPercent_get, _swigibpy.Order_trailingPercent_set)
    faGroup = _swig_property(_swigibpy.Order_faGroup_get, _swigibpy.Order_faGroup_set)
    faProfile = _swig_property(_swigibpy.Order_faProfile_get, _swigibpy.Order_faProfile_set)
    faMethod = _swig_property(_swigibpy.Order_faMethod_get, _swigibpy.Order_faMethod_set)
    faPercentage = _swig_property(_swigibpy.Order_faPercentage_get, _swigibpy.Order_faPercentage_set)
    openClose = _swig_property(_swigibpy.Order_openClose_get, _swigibpy.Order_openClose_set)
    origin = _swig_property(_swigibpy.Order_origin_get, _swigibpy.Order_origin_set)
    shortSaleSlot = _swig_property(_swigibpy.Order_shortSaleSlot_get, _swigibpy.Order_shortSaleSlot_set)
    designatedLocation = _swig_property(_swigibpy.Order_designatedLocation_get, _swigibpy.Order_designatedLocation_set)
    exemptCode = _swig_property(_swigibpy.Order_exemptCode_get, _swigibpy.Order_exemptCode_set)
    discretionaryAmt = _swig_property(_swigibpy.Order_discretionaryAmt_get, _swigibpy.Order_discretionaryAmt_set)
    eTradeOnly = _swig_property(_swigibpy.Order_eTradeOnly_get, _swigibpy.Order_eTradeOnly_set)
    firmQuoteOnly = _swig_property(_swigibpy.Order_firmQuoteOnly_get, _swigibpy.Order_firmQuoteOnly_set)
    nbboPriceCap = _swig_property(_swigibpy.Order_nbboPriceCap_get, _swigibpy.Order_nbboPriceCap_set)
    optOutSmartRouting = _swig_property(_swigibpy.Order_optOutSmartRouting_get, _swigibpy.Order_optOutSmartRouting_set)
    auctionStrategy = _swig_property(_swigibpy.Order_auctionStrategy_get, _swigibpy.Order_auctionStrategy_set)
    startingPrice = _swig_property(_swigibpy.Order_startingPrice_get, _swigibpy.Order_startingPrice_set)
    stockRefPrice = _swig_property(_swigibpy.Order_stockRefPrice_get, _swigibpy.Order_stockRefPrice_set)
    delta = _swig_property(_swigibpy.Order_delta_get, _swigibpy.Order_delta_set)
    stockRangeLower = _swig_property(_swigibpy.Order_stockRangeLower_get, _swigibpy.Order_stockRangeLower_set)
    stockRangeUpper = _swig_property(_swigibpy.Order_stockRangeUpper_get, _swigibpy.Order_stockRangeUpper_set)
    volatility = _swig_property(_swigibpy.Order_volatility_get, _swigibpy.Order_volatility_set)
    volatilityType = _swig_property(_swigibpy.Order_volatilityType_get, _swigibpy.Order_volatilityType_set)
    deltaNeutralOrderType = _swig_property(_swigibpy.Order_deltaNeutralOrderType_get, _swigibpy.Order_deltaNeutralOrderType_set)
    deltaNeutralAuxPrice = _swig_property(_swigibpy.Order_deltaNeutralAuxPrice_get, _swigibpy.Order_deltaNeutralAuxPrice_set)
    deltaNeutralConId = _swig_property(_swigibpy.Order_deltaNeutralConId_get, _swigibpy.Order_deltaNeutralConId_set)
    deltaNeutralSettlingFirm = _swig_property(_swigibpy.Order_deltaNeutralSettlingFirm_get, _swigibpy.Order_deltaNeutralSettlingFirm_set)
    deltaNeutralClearingAccount = _swig_property(_swigibpy.Order_deltaNeutralClearingAccount_get, _swigibpy.Order_deltaNeutralClearingAccount_set)
    deltaNeutralClearingIntent = _swig_property(_swigibpy.Order_deltaNeutralClearingIntent_get, _swigibpy.Order_deltaNeutralClearingIntent_set)
    deltaNeutralOpenClose = _swig_property(_swigibpy.Order_deltaNeutralOpenClose_get, _swigibpy.Order_deltaNeutralOpenClose_set)
    deltaNeutralShortSale = _swig_property(_swigibpy.Order_deltaNeutralShortSale_get, _swigibpy.Order_deltaNeutralShortSale_set)
    deltaNeutralShortSaleSlot = _swig_property(_swigibpy.Order_deltaNeutralShortSaleSlot_get, _swigibpy.Order_deltaNeutralShortSaleSlot_set)
    deltaNeutralDesignatedLocation = _swig_property(_swigibpy.Order_deltaNeutralDesignatedLocation_get, _swigibpy.Order_deltaNeutralDesignatedLocation_set)
    continuousUpdate = _swig_property(_swigibpy.Order_continuousUpdate_get, _swigibpy.Order_continuousUpdate_set)
    referencePriceType = _swig_property(_swigibpy.Order_referencePriceType_get, _swigibpy.Order_referencePriceType_set)
    basisPoints = _swig_property(_swigibpy.Order_basisPoints_get, _swigibpy.Order_basisPoints_set)
    basisPointsType = _swig_property(_swigibpy.Order_basisPointsType_get, _swigibpy.Order_basisPointsType_set)
    scaleInitLevelSize = _swig_property(_swigibpy.Order_scaleInitLevelSize_get, _swigibpy.Order_scaleInitLevelSize_set)
    scaleSubsLevelSize = _swig_property(_swigibpy.Order_scaleSubsLevelSize_get, _swigibpy.Order_scaleSubsLevelSize_set)
    scalePriceIncrement = _swig_property(_swigibpy.Order_scalePriceIncrement_get, _swigibpy.Order_scalePriceIncrement_set)
    scalePriceAdjustValue = _swig_property(_swigibpy.Order_scalePriceAdjustValue_get, _swigibpy.Order_scalePriceAdjustValue_set)
    scalePriceAdjustInterval = _swig_property(_swigibpy.Order_scalePriceAdjustInterval_get, _swigibpy.Order_scalePriceAdjustInterval_set)
    scaleProfitOffset = _swig_property(_swigibpy.Order_scaleProfitOffset_get, _swigibpy.Order_scaleProfitOffset_set)
    scaleAutoReset = _swig_property(_swigibpy.Order_scaleAutoReset_get, _swigibpy.Order_scaleAutoReset_set)
    scaleInitPosition = _swig_property(_swigibpy.Order_scaleInitPosition_get, _swigibpy.Order_scaleInitPosition_set)
    scaleInitFillQty = _swig_property(_swigibpy.Order_scaleInitFillQty_get, _swigibpy.Order_scaleInitFillQty_set)
    scaleRandomPercent = _swig_property(_swigibpy.Order_scaleRandomPercent_get, _swigibpy.Order_scaleRandomPercent_set)
    scaleTable = _swig_property(_swigibpy.Order_scaleTable_get, _swigibpy.Order_scaleTable_set)
    hedgeType = _swig_property(_swigibpy.Order_hedgeType_get, _swigibpy.Order_hedgeType_set)
    hedgeParam = _swig_property(_swigibpy.Order_hedgeParam_get, _swigibpy.Order_hedgeParam_set)
    account = _swig_property(_swigibpy.Order_account_get, _swigibpy.Order_account_set)
    settlingFirm = _swig_property(_swigibpy.Order_settlingFirm_get, _swigibpy.Order_settlingFirm_set)
    clearingAccount = _swig_property(_swigibpy.Order_clearingAccount_get, _swigibpy.Order_clearingAccount_set)
    clearingIntent = _swig_property(_swigibpy.Order_clearingIntent_get, _swigibpy.Order_clearingIntent_set)
    algoStrategy = _swig_property(_swigibpy.Order_algoStrategy_get, _swigibpy.Order_algoStrategy_set)
    algoParams = _swig_property(_swigibpy.Order_algoParams_get, _swigibpy.Order_algoParams_set)
    smartComboRoutingParams = _swig_property(_swigibpy.Order_smartComboRoutingParams_get, _swigibpy.Order_smartComboRoutingParams_set)
    whatIf = _swig_property(_swigibpy.Order_whatIf_get, _swigibpy.Order_whatIf_set)
    notHeld = _swig_property(_swigibpy.Order_notHeld_get, _swigibpy.Order_notHeld_set)
    orderComboLegs = _swig_property(_swigibpy.Order_orderComboLegs_get, _swigibpy.Order_orderComboLegs_set)
    orderMiscOptions = _swig_property(_swigibpy.Order_orderMiscOptions_get, _swigibpy.Order_orderMiscOptions_set)

    def CloneOrderComboLegs(dst, src):
        """CloneOrderComboLegs(Order::OrderComboLegListSPtr & dst, Order::OrderComboLegListSPtr const & src)"""
        return _swigibpy.Order_CloneOrderComboLegs(dst, src)

    CloneOrderComboLegs = staticmethod(CloneOrderComboLegs)
    __swig_destroy__ = _swigibpy.delete_Order
Order_swigregister = _swigibpy.Order_swigregister
Order_swigregister(Order)

def Order_CloneOrderComboLegs(dst, src):
    """Order_CloneOrderComboLegs(Order::OrderComboLegListSPtr & dst, Order::OrderComboLegListSPtr const & src)"""
    return _swigibpy.Order_CloneOrderComboLegs(dst, src)

class OrderState(object):
    """Proxy of C++ OrderState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(OrderState self) -> OrderState"""
        _swigibpy.OrderState_swiginit(self, _swigibpy.new_OrderState())
    status = _swig_property(_swigibpy.OrderState_status_get, _swigibpy.OrderState_status_set)
    initMargin = _swig_property(_swigibpy.OrderState_initMargin_get, _swigibpy.OrderState_initMargin_set)
    maintMargin = _swig_property(_swigibpy.OrderState_maintMargin_get, _swigibpy.OrderState_maintMargin_set)
    equityWithLoan = _swig_property(_swigibpy.OrderState_equityWithLoan_get, _swigibpy.OrderState_equityWithLoan_set)
    commission = _swig_property(_swigibpy.OrderState_commission_get, _swigibpy.OrderState_commission_set)
    minCommission = _swig_property(_swigibpy.OrderState_minCommission_get, _swigibpy.OrderState_minCommission_set)
    maxCommission = _swig_property(_swigibpy.OrderState_maxCommission_get, _swigibpy.OrderState_maxCommission_set)
    commissionCurrency = _swig_property(_swigibpy.OrderState_commissionCurrency_get, _swigibpy.OrderState_commissionCurrency_set)
    warningText = _swig_property(_swigibpy.OrderState_warningText_get, _swigibpy.OrderState_warningText_set)
    __swig_destroy__ = _swigibpy.delete_OrderState
OrderState_swigregister = _swigibpy.OrderState_swigregister
OrderState_swigregister(OrderState)


_swigibpy.NO_ROW_NUMBER_SPECIFIED_swigconstant(_swigibpy)
NO_ROW_NUMBER_SPECIFIED = _swigibpy.NO_ROW_NUMBER_SPECIFIED
class ScannerSubscription(object):
    """Proxy of C++ ScannerSubscription class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ScannerSubscription self) -> ScannerSubscription"""
        _swigibpy.ScannerSubscription_swiginit(self, _swigibpy.new_ScannerSubscription())
    numberOfRows = _swig_property(_swigibpy.ScannerSubscription_numberOfRows_get, _swigibpy.ScannerSubscription_numberOfRows_set)
    instrument = _swig_property(_swigibpy.ScannerSubscription_instrument_get, _swigibpy.ScannerSubscription_instrument_set)
    locationCode = _swig_property(_swigibpy.ScannerSubscription_locationCode_get, _swigibpy.ScannerSubscription_locationCode_set)
    scanCode = _swig_property(_swigibpy.ScannerSubscription_scanCode_get, _swigibpy.ScannerSubscription_scanCode_set)
    abovePrice = _swig_property(_swigibpy.ScannerSubscription_abovePrice_get, _swigibpy.ScannerSubscription_abovePrice_set)
    belowPrice = _swig_property(_swigibpy.ScannerSubscription_belowPrice_get, _swigibpy.ScannerSubscription_belowPrice_set)
    aboveVolume = _swig_property(_swigibpy.ScannerSubscription_aboveVolume_get, _swigibpy.ScannerSubscription_aboveVolume_set)
    marketCapAbove = _swig_property(_swigibpy.ScannerSubscription_marketCapAbove_get, _swigibpy.ScannerSubscription_marketCapAbove_set)
    marketCapBelow = _swig_property(_swigibpy.ScannerSubscription_marketCapBelow_get, _swigibpy.ScannerSubscription_marketCapBelow_set)
    moodyRatingAbove = _swig_property(_swigibpy.ScannerSubscription_moodyRatingAbove_get, _swigibpy.ScannerSubscription_moodyRatingAbove_set)
    moodyRatingBelow = _swig_property(_swigibpy.ScannerSubscription_moodyRatingBelow_get, _swigibpy.ScannerSubscription_moodyRatingBelow_set)
    spRatingAbove = _swig_property(_swigibpy.ScannerSubscription_spRatingAbove_get, _swigibpy.ScannerSubscription_spRatingAbove_set)
    spRatingBelow = _swig_property(_swigibpy.ScannerSubscription_spRatingBelow_get, _swigibpy.ScannerSubscription_spRatingBelow_set)
    maturityDateAbove = _swig_property(_swigibpy.ScannerSubscription_maturityDateAbove_get, _swigibpy.ScannerSubscription_maturityDateAbove_set)
    maturityDateBelow = _swig_property(_swigibpy.ScannerSubscription_maturityDateBelow_get, _swigibpy.ScannerSubscription_maturityDateBelow_set)
    couponRateAbove = _swig_property(_swigibpy.ScannerSubscription_couponRateAbove_get, _swigibpy.ScannerSubscription_couponRateAbove_set)
    couponRateBelow = _swig_property(_swigibpy.ScannerSubscription_couponRateBelow_get, _swigibpy.ScannerSubscription_couponRateBelow_set)
    excludeConvertible = _swig_property(_swigibpy.ScannerSubscription_excludeConvertible_get, _swigibpy.ScannerSubscription_excludeConvertible_set)
    averageOptionVolumeAbove = _swig_property(_swigibpy.ScannerSubscription_averageOptionVolumeAbove_get, _swigibpy.ScannerSubscription_averageOptionVolumeAbove_set)
    scannerSettingPairs = _swig_property(_swigibpy.ScannerSubscription_scannerSettingPairs_get, _swigibpy.ScannerSubscription_scannerSettingPairs_set)
    stockTypeFilter = _swig_property(_swigibpy.ScannerSubscription_stockTypeFilter_get, _swigibpy.ScannerSubscription_stockTypeFilter_set)
    __swig_destroy__ = _swigibpy.delete_ScannerSubscription
ScannerSubscription_swigregister = _swigibpy.ScannerSubscription_swigregister
ScannerSubscription_swigregister(ScannerSubscription)

class TagValue(object):
    """Proxy of C++ TagValue class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(TagValue self) -> TagValue
        __init__(TagValue self, IBString const & p_tag, IBString const & p_value) -> TagValue
        """
        _swigibpy.TagValue_swiginit(self, _swigibpy.new_TagValue(*args))
    tag = _swig_property(_swigibpy.TagValue_tag_get, _swigibpy.TagValue_tag_set)
    value = _swig_property(_swigibpy.TagValue_value_get, _swigibpy.TagValue_value_set)
    __swig_destroy__ = _swigibpy.delete_TagValue
TagValue_swigregister = _swigibpy.TagValue_swigregister
TagValue_swigregister(TagValue)



class TWSPoller(threading.Thread):
    '''Continually polls TWS for any outstanding messages.

    Loops indefinitely until killed or a system error occurs.

    Uses socket select to poll for input and calls TWS's
    `EClientSocketBase::checkMessages` function.
    '''

    MAX_BACKOFF = 5000

    def __init__(self, tws, wrapper):
        super(TWSPoller, self).__init__()
        self.daemon = True
        self._tws = tws
        self._wrapper = wrapper
        self._stop_evt = threading.Event()
        self._connected_evt = threading.Event()

        self.tws_connected(tws.isConnected())

    def stop_poller(self):
        self._stop_evt.set()

    def tws_connected(self, flag):
        if flag:
            self._connected_evt.set()
        else:
            self._connected_evt.clear()

    def run(self):
        modules = sys.modules
        try:
            self._run()
        except:
# ignore errors raised during interpreter shutdown.
            if modules:
                raise

    def _run(self):
        '''Continually poll TWS'''
        stop = self._stop_evt
        connected = self._connected_evt
        tws = self._tws

        fd = tws.fd()
        pollfd = [fd]

        while not stop.is_set():
            while (not connected.is_set() or not tws.isConnected()) and not stop.is_set():
                connected.clear()
                backoff = 0
                retries = 0

                while not connected.is_set() and not stop.is_set():
                    if tws.reconnect_auto and not tws.reconnect():
                        if backoff < self.MAX_BACKOFF:
                            retries += 1
                            backoff = min(2**(retries + 1), self.MAX_BACKOFF)
                        connected.wait(backoff / 1000.)
                    else:
                        connected.wait(1)
                fd = tws.fd()
                pollfd = [fd]

            if fd > 0:
                try:
                    evtin, _evtout, evterr = select.select(pollfd, [], pollfd, 1)
                except select.error:
                    connected.clear()
                    continue
                else:
                    if fd in evtin:
                        try:
                            if not tws.checkMessages():
                                tws.eDisconnect(stop_polling=False)
                                continue
                        except (SystemExit, SystemError, KeyboardInterrupt):
                            break
                        except:
                            try:
                                self._wrapper.pyError(*sys.exc_info())
                            except:
                                print_exc()
                    elif fd in evterr:
                        connected.clear()
                        continue

class EPosixClientSocket(EClientSocketBase):
    """Proxy of C++ EPosixClientSocket class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ewrapper, poll_auto=True, reconnect_auto=False):
        '''Create an EPosixClientSocket to comunicate with Interactive Brokers.

        Parameters
        ----------
        ewrapper : EWrapper subclass to which responses will be dispatched.
        poll_auto : boolean, if True automatically poll for messages with a
            background thread. Default True
        reconnect_auto : boolean, if True automatically reconnect to TWS if
            the connection is lost. Default False
        '''
        _swigibpy.EPosixClientSocket_swiginit(self, _swigibpy.new_EPosixClientSocket(ewrapper))

    # store a reference to EWrapper on the Python side (C++ member is protected so inaccessible from Python).
        self._ewrapper = ewrapper

        self._connect_lock = threading.Lock()
        self.poller = None
        self._poll_auto = poll_auto
        self.reconnect_auto = reconnect_auto
        self._connect_args = None


    __swig_destroy__ = _swigibpy.delete_EPosixClientSocket

    def eConnect(self, host, port, clientId=0, extraAuth=False, **kwargs):
        if "poll_auto" in kwargs:
            warnings.warn("eConnect argument 'poll_auto' is deprecated, use 'poll_auto' arg in constructor instead", DeprecationWarning)
            self.poll_auto = kwargs.pop('poll_auto')

        with self._connect_lock:
            success = _swigibpy.EPosixClientSocket_eConnect(self, host, port, clientId, extraAuth)

        if success:
            self._connect_args = ((host, port, clientId, extraAuth), kwargs)
        if self.isConnected():
            self._startPolling()
            if self.poller is not None:
                self.poller.tws_connected(True)
        return success



    def eDisconnect(self, stop_polling=True):
        if stop_polling:
            self._stopPolling()
        val = _swigibpy.EPosixClientSocket_eDisconnect(self)
        if self.poller is not None:
            self.poller.tws_connected(False)
        return val



    def isSocketOK(self):
        """isSocketOK(EPosixClientSocket self) -> bool"""
        return _swigibpy.EPosixClientSocket_isSocketOK(self)


    def fd(self):
        """fd(EPosixClientSocket self) -> int"""
        return _swigibpy.EPosixClientSocket_fd(self)


    def onReceive(self):
        """onReceive(EPosixClientSocket self)"""
        return _swigibpy.EPosixClientSocket_onReceive(self)


    def onSend(self):
        """onSend(EPosixClientSocket self)"""
        return _swigibpy.EPosixClientSocket_onSend(self)


    def onError(self):
        """onError(EPosixClientSocket self)"""
        return _swigibpy.EPosixClientSocket_onError(self)


    def handleSocketError(self):
        """handleSocketError(EPosixClientSocket self) -> bool"""
        return _swigibpy.EPosixClientSocket_handleSocketError(self)



    def reconnect(self):
        if self._connect_args is None:
            return
        return self.eConnect(*self._connect_args[0], **self._connect_args[1])

    def _startPolling(self):
        if not self.poll_auto:
            return
        if  self.poller is None or not self.poller.is_alive():
            self.poller = TWSPoller(self, self._ewrapper)
            self.poller.start()

    def _stopPolling(self):
        if self.poller is not None:
            self.poller.stop_poller()

    @property
    def poll_auto(self):
        return self._poll_auto

    @poll_auto.setter
    def poll_auto(self, val):
        self._poll_auto = val
        if val:
            self._startPolling()
        else:
            self._stopPolling()

EPosixClientSocket.isSocketOK = new_instancemethod(_swigibpy.EPosixClientSocket_isSocketOK, None, EPosixClientSocket)
EPosixClientSocket.fd = new_instancemethod(_swigibpy.EPosixClientSocket_fd, None, EPosixClientSocket)
EPosixClientSocket.onReceive = new_instancemethod(_swigibpy.EPosixClientSocket_onReceive, None, EPosixClientSocket)
EPosixClientSocket.onSend = new_instancemethod(_swigibpy.EPosixClientSocket_onSend, None, EPosixClientSocket)
EPosixClientSocket.onError = new_instancemethod(_swigibpy.EPosixClientSocket_onError, None, EPosixClientSocket)
EPosixClientSocket.handleSocketError = new_instancemethod(_swigibpy.EPosixClientSocket_handleSocketError, None, EPosixClientSocket)
EPosixClientSocket_swigregister = _swigibpy.EPosixClientSocket_swigregister
EPosixClientSocket_swigregister(EPosixClientSocket)


_swigibpy.BID_SIZE_swigconstant(_swigibpy)
BID_SIZE = _swigibpy.BID_SIZE

_swigibpy.BID_swigconstant(_swigibpy)
BID = _swigibpy.BID

_swigibpy.ASK_swigconstant(_swigibpy)
ASK = _swigibpy.ASK

_swigibpy.ASK_SIZE_swigconstant(_swigibpy)
ASK_SIZE = _swigibpy.ASK_SIZE

_swigibpy.LAST_swigconstant(_swigibpy)
LAST = _swigibpy.LAST

_swigibpy.LAST_SIZE_swigconstant(_swigibpy)
LAST_SIZE = _swigibpy.LAST_SIZE

_swigibpy.HIGH_swigconstant(_swigibpy)
HIGH = _swigibpy.HIGH

_swigibpy.LOW_swigconstant(_swigibpy)
LOW = _swigibpy.LOW

_swigibpy.VOLUME_swigconstant(_swigibpy)
VOLUME = _swigibpy.VOLUME

_swigibpy.CLOSE_swigconstant(_swigibpy)
CLOSE = _swigibpy.CLOSE

_swigibpy.BID_OPTION_COMPUTATION_swigconstant(_swigibpy)
BID_OPTION_COMPUTATION = _swigibpy.BID_OPTION_COMPUTATION

_swigibpy.ASK_OPTION_COMPUTATION_swigconstant(_swigibpy)
ASK_OPTION_COMPUTATION = _swigibpy.ASK_OPTION_COMPUTATION

_swigibpy.LAST_OPTION_COMPUTATION_swigconstant(_swigibpy)
LAST_OPTION_COMPUTATION = _swigibpy.LAST_OPTION_COMPUTATION

_swigibpy.MODEL_OPTION_swigconstant(_swigibpy)
MODEL_OPTION = _swigibpy.MODEL_OPTION

_swigibpy.OPEN_swigconstant(_swigibpy)
OPEN = _swigibpy.OPEN

_swigibpy.LOW_13_WEEK_swigconstant(_swigibpy)
LOW_13_WEEK = _swigibpy.LOW_13_WEEK

_swigibpy.HIGH_13_WEEK_swigconstant(_swigibpy)
HIGH_13_WEEK = _swigibpy.HIGH_13_WEEK

_swigibpy.LOW_26_WEEK_swigconstant(_swigibpy)
LOW_26_WEEK = _swigibpy.LOW_26_WEEK

_swigibpy.HIGH_26_WEEK_swigconstant(_swigibpy)
HIGH_26_WEEK = _swigibpy.HIGH_26_WEEK

_swigibpy.LOW_52_WEEK_swigconstant(_swigibpy)
LOW_52_WEEK = _swigibpy.LOW_52_WEEK

_swigibpy.HIGH_52_WEEK_swigconstant(_swigibpy)
HIGH_52_WEEK = _swigibpy.HIGH_52_WEEK

_swigibpy.AVG_VOLUME_swigconstant(_swigibpy)
AVG_VOLUME = _swigibpy.AVG_VOLUME

_swigibpy.OPEN_INTEREST_swigconstant(_swigibpy)
OPEN_INTEREST = _swigibpy.OPEN_INTEREST

_swigibpy.OPTION_HISTORICAL_VOL_swigconstant(_swigibpy)
OPTION_HISTORICAL_VOL = _swigibpy.OPTION_HISTORICAL_VOL

_swigibpy.OPTION_IMPLIED_VOL_swigconstant(_swigibpy)
OPTION_IMPLIED_VOL = _swigibpy.OPTION_IMPLIED_VOL

_swigibpy.OPTION_BID_EXCH_swigconstant(_swigibpy)
OPTION_BID_EXCH = _swigibpy.OPTION_BID_EXCH

_swigibpy.OPTION_ASK_EXCH_swigconstant(_swigibpy)
OPTION_ASK_EXCH = _swigibpy.OPTION_ASK_EXCH

_swigibpy.OPTION_CALL_OPEN_INTEREST_swigconstant(_swigibpy)
OPTION_CALL_OPEN_INTEREST = _swigibpy.OPTION_CALL_OPEN_INTEREST

_swigibpy.OPTION_PUT_OPEN_INTEREST_swigconstant(_swigibpy)
OPTION_PUT_OPEN_INTEREST = _swigibpy.OPTION_PUT_OPEN_INTEREST

_swigibpy.OPTION_CALL_VOLUME_swigconstant(_swigibpy)
OPTION_CALL_VOLUME = _swigibpy.OPTION_CALL_VOLUME

_swigibpy.OPTION_PUT_VOLUME_swigconstant(_swigibpy)
OPTION_PUT_VOLUME = _swigibpy.OPTION_PUT_VOLUME

_swigibpy.INDEX_FUTURE_PREMIUM_swigconstant(_swigibpy)
INDEX_FUTURE_PREMIUM = _swigibpy.INDEX_FUTURE_PREMIUM

_swigibpy.BID_EXCH_swigconstant(_swigibpy)
BID_EXCH = _swigibpy.BID_EXCH

_swigibpy.ASK_EXCH_swigconstant(_swigibpy)
ASK_EXCH = _swigibpy.ASK_EXCH

_swigibpy.AUCTION_VOLUME_swigconstant(_swigibpy)
AUCTION_VOLUME = _swigibpy.AUCTION_VOLUME

_swigibpy.AUCTION_PRICE_swigconstant(_swigibpy)
AUCTION_PRICE = _swigibpy.AUCTION_PRICE

_swigibpy.AUCTION_IMBALANCE_swigconstant(_swigibpy)
AUCTION_IMBALANCE = _swigibpy.AUCTION_IMBALANCE

_swigibpy.MARK_PRICE_swigconstant(_swigibpy)
MARK_PRICE = _swigibpy.MARK_PRICE

_swigibpy.BID_EFP_COMPUTATION_swigconstant(_swigibpy)
BID_EFP_COMPUTATION = _swigibpy.BID_EFP_COMPUTATION

_swigibpy.ASK_EFP_COMPUTATION_swigconstant(_swigibpy)
ASK_EFP_COMPUTATION = _swigibpy.ASK_EFP_COMPUTATION

_swigibpy.LAST_EFP_COMPUTATION_swigconstant(_swigibpy)
LAST_EFP_COMPUTATION = _swigibpy.LAST_EFP_COMPUTATION

_swigibpy.OPEN_EFP_COMPUTATION_swigconstant(_swigibpy)
OPEN_EFP_COMPUTATION = _swigibpy.OPEN_EFP_COMPUTATION

_swigibpy.HIGH_EFP_COMPUTATION_swigconstant(_swigibpy)
HIGH_EFP_COMPUTATION = _swigibpy.HIGH_EFP_COMPUTATION

_swigibpy.LOW_EFP_COMPUTATION_swigconstant(_swigibpy)
LOW_EFP_COMPUTATION = _swigibpy.LOW_EFP_COMPUTATION

_swigibpy.CLOSE_EFP_COMPUTATION_swigconstant(_swigibpy)
CLOSE_EFP_COMPUTATION = _swigibpy.CLOSE_EFP_COMPUTATION

_swigibpy.LAST_TIMESTAMP_swigconstant(_swigibpy)
LAST_TIMESTAMP = _swigibpy.LAST_TIMESTAMP

_swigibpy.SHORTABLE_swigconstant(_swigibpy)
SHORTABLE = _swigibpy.SHORTABLE

_swigibpy.FUNDAMENTAL_RATIOS_swigconstant(_swigibpy)
FUNDAMENTAL_RATIOS = _swigibpy.FUNDAMENTAL_RATIOS

_swigibpy.RT_VOLUME_swigconstant(_swigibpy)
RT_VOLUME = _swigibpy.RT_VOLUME

_swigibpy.HALTED_swigconstant(_swigibpy)
HALTED = _swigibpy.HALTED

_swigibpy.BID_YIELD_swigconstant(_swigibpy)
BID_YIELD = _swigibpy.BID_YIELD

_swigibpy.ASK_YIELD_swigconstant(_swigibpy)
ASK_YIELD = _swigibpy.ASK_YIELD

_swigibpy.LAST_YIELD_swigconstant(_swigibpy)
LAST_YIELD = _swigibpy.LAST_YIELD

_swigibpy.CUST_OPTION_COMPUTATION_swigconstant(_swigibpy)
CUST_OPTION_COMPUTATION = _swigibpy.CUST_OPTION_COMPUTATION

_swigibpy.TRADE_COUNT_swigconstant(_swigibpy)
TRADE_COUNT = _swigibpy.TRADE_COUNT

_swigibpy.TRADE_RATE_swigconstant(_swigibpy)
TRADE_RATE = _swigibpy.TRADE_RATE

_swigibpy.VOLUME_RATE_swigconstant(_swigibpy)
VOLUME_RATE = _swigibpy.VOLUME_RATE

_swigibpy.LAST_RTH_TRADE_swigconstant(_swigibpy)
LAST_RTH_TRADE = _swigibpy.LAST_RTH_TRADE

_swigibpy.NOT_SET_swigconstant(_swigibpy)
NOT_SET = _swigibpy.NOT_SET

def isPrice(tickType):
    """isPrice(TickType tickType) -> bool"""
    return _swigibpy.isPrice(tickType)
class EWrapper(object):
    """Proxy of C++ EWrapper class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _swigibpy.delete_EWrapper

    def tickPrice(self, tickerId, field, price, canAutoExecute):
        """tickPrice(EWrapper self, TickerId tickerId, TickType field, double price, int canAutoExecute)"""
        return _swigibpy.EWrapper_tickPrice(self, tickerId, field, price, canAutoExecute)


    def tickSize(self, tickerId, field, size):
        """tickSize(EWrapper self, TickerId tickerId, TickType field, int size)"""
        return _swigibpy.EWrapper_tickSize(self, tickerId, field, size)


    def tickOptionComputation(self, tickerId, tickType, impliedVol, delta, optPrice, pvDividend, gamma, vega, theta, undPrice):
        """tickOptionComputation(EWrapper self, TickerId tickerId, TickType tickType, double impliedVol, double delta, double optPrice, double pvDividend, double gamma, double vega, double theta, double undPrice)"""
        return _swigibpy.EWrapper_tickOptionComputation(self, tickerId, tickType, impliedVol, delta, optPrice, pvDividend, gamma, vega, theta, undPrice)


    def tickGeneric(self, tickerId, tickType, value):
        """tickGeneric(EWrapper self, TickerId tickerId, TickType tickType, double value)"""
        return _swigibpy.EWrapper_tickGeneric(self, tickerId, tickType, value)


    def tickString(self, tickerId, tickType, value):
        """tickString(EWrapper self, TickerId tickerId, TickType tickType, IBString const & value)"""
        return _swigibpy.EWrapper_tickString(self, tickerId, tickType, value)


    def tickEFP(self, tickerId, tickType, basisPoints, formattedBasisPoints, totalDividends, holdDays, futureExpiry, dividendImpact, dividendsToExpiry):
        """tickEFP(EWrapper self, TickerId tickerId, TickType tickType, double basisPoints, IBString const & formattedBasisPoints, double totalDividends, int holdDays, IBString const & futureExpiry, double dividendImpact, double dividendsToExpiry)"""
        return _swigibpy.EWrapper_tickEFP(self, tickerId, tickType, basisPoints, formattedBasisPoints, totalDividends, holdDays, futureExpiry, dividendImpact, dividendsToExpiry)


    def orderStatus(self, orderId, status, filled, remaining, avgFillPrice, permId, parentId, lastFillPrice, clientId, whyHeld):
        """orderStatus(EWrapper self, OrderId orderId, IBString const & status, int filled, int remaining, double avgFillPrice, int permId, int parentId, double lastFillPrice, int clientId, IBString const & whyHeld)"""
        return _swigibpy.EWrapper_orderStatus(self, orderId, status, filled, remaining, avgFillPrice, permId, parentId, lastFillPrice, clientId, whyHeld)


    def openOrder(self, orderId, arg0, arg1, arg2):
        """openOrder(EWrapper self, OrderId orderId, Contract arg0, Order arg1, OrderState arg2)"""
        return _swigibpy.EWrapper_openOrder(self, orderId, arg0, arg1, arg2)


    def openOrderEnd(self):
        """openOrderEnd(EWrapper self)"""
        return _swigibpy.EWrapper_openOrderEnd(self)


    def winError(self, str, lastError):
        '''Error in TWS API library'''
        sys.stderr.write("TWS ERROR - %s: %s\n" % (lastError, str))



    def connectionClosed(self):
        """connectionClosed(EWrapper self)"""
        return _swigibpy.EWrapper_connectionClosed(self)


    def updateAccountValue(self, key, val, currency, accountName):
        """updateAccountValue(EWrapper self, IBString const & key, IBString const & val, IBString const & currency, IBString const & accountName)"""
        return _swigibpy.EWrapper_updateAccountValue(self, key, val, currency, accountName)


    def updatePortfolio(self, contract, position, marketPrice, marketValue, averageCost, unrealizedPNL, realizedPNL, accountName):
        """updatePortfolio(EWrapper self, Contract contract, int position, double marketPrice, double marketValue, double averageCost, double unrealizedPNL, double realizedPNL, IBString const & accountName)"""
        return _swigibpy.EWrapper_updatePortfolio(self, contract, position, marketPrice, marketValue, averageCost, unrealizedPNL, realizedPNL, accountName)


    def updateAccountTime(self, timeStamp):
        """updateAccountTime(EWrapper self, IBString const & timeStamp)"""
        return _swigibpy.EWrapper_updateAccountTime(self, timeStamp)


    def accountDownloadEnd(self, accountName):
        """accountDownloadEnd(EWrapper self, IBString const & accountName)"""
        return _swigibpy.EWrapper_accountDownloadEnd(self, accountName)


    def nextValidId(self, orderId):
        """nextValidId(EWrapper self, OrderId orderId)"""
        return _swigibpy.EWrapper_nextValidId(self, orderId)


    def contractDetails(self, reqId, contractDetails):
        """contractDetails(EWrapper self, int reqId, ContractDetails contractDetails)"""
        return _swigibpy.EWrapper_contractDetails(self, reqId, contractDetails)


    def bondContractDetails(self, reqId, contractDetails):
        """bondContractDetails(EWrapper self, int reqId, ContractDetails contractDetails)"""
        return _swigibpy.EWrapper_bondContractDetails(self, reqId, contractDetails)


    def contractDetailsEnd(self, reqId):
        """contractDetailsEnd(EWrapper self, int reqId)"""
        return _swigibpy.EWrapper_contractDetailsEnd(self, reqId)


    def execDetails(self, reqId, contract, execution):
        """execDetails(EWrapper self, int reqId, Contract contract, Execution execution)"""
        return _swigibpy.EWrapper_execDetails(self, reqId, contract, execution)


    def execDetailsEnd(self, reqId):
        """execDetailsEnd(EWrapper self, int reqId)"""
        return _swigibpy.EWrapper_execDetailsEnd(self, reqId)


    def error(self, id, errorCode, errorString):
        '''Error during communication with TWS'''
        if errorCode == 165: # Historical data sevice message
            sys.stderr.write("TWS INFO - %s: %s\n" % (errorCode, errorString))
        elif errorCode >= 501 and errorCode < 600: # Socket read failed
            sys.stderr.write("TWS CLIENT-ERROR - %s: %s\n" % (errorCode, errorString))
        elif errorCode >= 100 and errorCode < 1100:
            sys.stderr.write("TWS ERROR - %s: %s\n" % (errorCode, errorString))
        elif errorCode >= 1100 and errorCode < 2100:
            sys.stderr.write("TWS SYSTEM-ERROR - %s: %s\n" % (errorCode, errorString))
        elif errorCode in (2104, 2106, 2108):
            sys.stderr.write("TWS INFO - %s: %s\n" % (errorCode, errorString))
        elif errorCode >= 2100 and errorCode <= 2110:
            sys.stderr.write("TWS WARNING - %s: %s\n" % (errorCode, errorString))
        else:
            sys.stderr.write("TWS ERROR - %s: %s\n" % (errorCode, errorString))



    def updateMktDepth(self, id, position, operation, side, price, size):
        """updateMktDepth(EWrapper self, TickerId id, int position, int operation, int side, double price, int size)"""
        return _swigibpy.EWrapper_updateMktDepth(self, id, position, operation, side, price, size)


    def updateMktDepthL2(self, id, position, marketMaker, operation, side, price, size):
        """updateMktDepthL2(EWrapper self, TickerId id, int position, IBString marketMaker, int operation, int side, double price, int size)"""
        return _swigibpy.EWrapper_updateMktDepthL2(self, id, position, marketMaker, operation, side, price, size)


    def updateNewsBulletin(self, msgId, msgType, newsMessage, originExch):
        """updateNewsBulletin(EWrapper self, int msgId, int msgType, IBString const & newsMessage, IBString const & originExch)"""
        return _swigibpy.EWrapper_updateNewsBulletin(self, msgId, msgType, newsMessage, originExch)


    def managedAccounts(self, accountsList):
        """managedAccounts(EWrapper self, IBString const & accountsList)"""
        return _swigibpy.EWrapper_managedAccounts(self, accountsList)


    def receiveFA(self, pFaDataType, cxml):
        """receiveFA(EWrapper self, faDataType pFaDataType, IBString const & cxml)"""
        return _swigibpy.EWrapper_receiveFA(self, pFaDataType, cxml)


    def historicalData(self, reqId, date, open, high, low, close, volume, barCount, WAP, hasGaps):
        """historicalData(EWrapper self, TickerId reqId, IBString const & date, double open, double high, double low, double close, int volume, int barCount, double WAP, int hasGaps)"""
        return _swigibpy.EWrapper_historicalData(self, reqId, date, open, high, low, close, volume, barCount, WAP, hasGaps)


    def scannerParameters(self, xml):
        """scannerParameters(EWrapper self, IBString const & xml)"""
        return _swigibpy.EWrapper_scannerParameters(self, xml)


    def scannerData(self, reqId, rank, contractDetails, distance, benchmark, projection, legsStr):
        """scannerData(EWrapper self, int reqId, int rank, ContractDetails contractDetails, IBString const & distance, IBString const & benchmark, IBString const & projection, IBString const & legsStr)"""
        return _swigibpy.EWrapper_scannerData(self, reqId, rank, contractDetails, distance, benchmark, projection, legsStr)


    def scannerDataEnd(self, reqId):
        """scannerDataEnd(EWrapper self, int reqId)"""
        return _swigibpy.EWrapper_scannerDataEnd(self, reqId)


    def realtimeBar(self, reqId, time, open, high, low, close, volume, wap, count):
        """realtimeBar(EWrapper self, TickerId reqId, long time, double open, double high, double low, double close, long volume, double wap, int count)"""
        return _swigibpy.EWrapper_realtimeBar(self, reqId, time, open, high, low, close, volume, wap, count)


    def currentTime(self, time):
        """currentTime(EWrapper self, long time)"""
        return _swigibpy.EWrapper_currentTime(self, time)


    def fundamentalData(self, reqId, data):
        """fundamentalData(EWrapper self, TickerId reqId, IBString const & data)"""
        return _swigibpy.EWrapper_fundamentalData(self, reqId, data)


    def deltaNeutralValidation(self, reqId, underComp):
        """deltaNeutralValidation(EWrapper self, int reqId, UnderComp underComp)"""
        return _swigibpy.EWrapper_deltaNeutralValidation(self, reqId, underComp)


    def tickSnapshotEnd(self, reqId):
        """tickSnapshotEnd(EWrapper self, int reqId)"""
        return _swigibpy.EWrapper_tickSnapshotEnd(self, reqId)


    def marketDataType(self, reqId, marketDataType):
        """marketDataType(EWrapper self, TickerId reqId, int marketDataType)"""
        return _swigibpy.EWrapper_marketDataType(self, reqId, marketDataType)


    def commissionReport(self, commissionReport):
        """commissionReport(EWrapper self, CommissionReport commissionReport)"""
        return _swigibpy.EWrapper_commissionReport(self, commissionReport)


    def position(self, account, contract, position, avgCost):
        """position(EWrapper self, IBString const & account, Contract contract, int position, double avgCost)"""
        return _swigibpy.EWrapper_position(self, account, contract, position, avgCost)


    def positionEnd(self):
        """positionEnd(EWrapper self)"""
        return _swigibpy.EWrapper_positionEnd(self)


    def accountSummary(self, reqId, account, tag, value, curency):
        """accountSummary(EWrapper self, int reqId, IBString const & account, IBString const & tag, IBString const & value, IBString const & curency)"""
        return _swigibpy.EWrapper_accountSummary(self, reqId, account, tag, value, curency)


    def accountSummaryEnd(self, reqId):
        """accountSummaryEnd(EWrapper self, int reqId)"""
        return _swigibpy.EWrapper_accountSummaryEnd(self, reqId)


    def verifyMessageAPI(self, apiData):
        """verifyMessageAPI(EWrapper self, IBString const & apiData)"""
        return _swigibpy.EWrapper_verifyMessageAPI(self, apiData)


    def verifyCompleted(self, isSuccessful, errorText):
        """verifyCompleted(EWrapper self, bool isSuccessful, IBString const & errorText)"""
        return _swigibpy.EWrapper_verifyCompleted(self, isSuccessful, errorText)


    def displayGroupList(self, reqId, groups):
        """displayGroupList(EWrapper self, int reqId, IBString const & groups)"""
        return _swigibpy.EWrapper_displayGroupList(self, reqId, groups)


    def displayGroupUpdated(self, reqId, contractInfo):
        """displayGroupUpdated(EWrapper self, int reqId, IBString const & contractInfo)"""
        return _swigibpy.EWrapper_displayGroupUpdated(self, reqId, contractInfo)


    def pyError(self, type, value, traceback):
        '''Handles an error thrown during invocation of an EWrapper method.

        Arguments are those provided by sys.exc_info()
        '''
        sys.stderr.write("Exception thrown during EWrapper method dispatch:\n")
        print_exception(type, value, traceback)


    def __init__(self):
        """__init__(EWrapper self) -> EWrapper"""
        if self.__class__ == EWrapper:
            _self = None
        else:
            _self = self
        _swigibpy.EWrapper_swiginit(self, _swigibpy.new_EWrapper(_self, ))
    def __disown__(self):
        self.this.disown()
        _swigibpy.disown_EWrapper(self)
        return weakref_proxy(self)
EWrapper.tickPrice = new_instancemethod(_swigibpy.EWrapper_tickPrice, None, EWrapper)
EWrapper.tickSize = new_instancemethod(_swigibpy.EWrapper_tickSize, None, EWrapper)
EWrapper.tickOptionComputation = new_instancemethod(_swigibpy.EWrapper_tickOptionComputation, None, EWrapper)
EWrapper.tickGeneric = new_instancemethod(_swigibpy.EWrapper_tickGeneric, None, EWrapper)
EWrapper.tickString = new_instancemethod(_swigibpy.EWrapper_tickString, None, EWrapper)
EWrapper.tickEFP = new_instancemethod(_swigibpy.EWrapper_tickEFP, None, EWrapper)
EWrapper.orderStatus = new_instancemethod(_swigibpy.EWrapper_orderStatus, None, EWrapper)
EWrapper.openOrder = new_instancemethod(_swigibpy.EWrapper_openOrder, None, EWrapper)
EWrapper.openOrderEnd = new_instancemethod(_swigibpy.EWrapper_openOrderEnd, None, EWrapper)
EWrapper.connectionClosed = new_instancemethod(_swigibpy.EWrapper_connectionClosed, None, EWrapper)
EWrapper.updateAccountValue = new_instancemethod(_swigibpy.EWrapper_updateAccountValue, None, EWrapper)
EWrapper.updatePortfolio = new_instancemethod(_swigibpy.EWrapper_updatePortfolio, None, EWrapper)
EWrapper.updateAccountTime = new_instancemethod(_swigibpy.EWrapper_updateAccountTime, None, EWrapper)
EWrapper.accountDownloadEnd = new_instancemethod(_swigibpy.EWrapper_accountDownloadEnd, None, EWrapper)
EWrapper.nextValidId = new_instancemethod(_swigibpy.EWrapper_nextValidId, None, EWrapper)
EWrapper.contractDetails = new_instancemethod(_swigibpy.EWrapper_contractDetails, None, EWrapper)
EWrapper.bondContractDetails = new_instancemethod(_swigibpy.EWrapper_bondContractDetails, None, EWrapper)
EWrapper.contractDetailsEnd = new_instancemethod(_swigibpy.EWrapper_contractDetailsEnd, None, EWrapper)
EWrapper.execDetails = new_instancemethod(_swigibpy.EWrapper_execDetails, None, EWrapper)
EWrapper.execDetailsEnd = new_instancemethod(_swigibpy.EWrapper_execDetailsEnd, None, EWrapper)
EWrapper.updateMktDepth = new_instancemethod(_swigibpy.EWrapper_updateMktDepth, None, EWrapper)
EWrapper.updateMktDepthL2 = new_instancemethod(_swigibpy.EWrapper_updateMktDepthL2, None, EWrapper)
EWrapper.updateNewsBulletin = new_instancemethod(_swigibpy.EWrapper_updateNewsBulletin, None, EWrapper)
EWrapper.managedAccounts = new_instancemethod(_swigibpy.EWrapper_managedAccounts, None, EWrapper)
EWrapper.receiveFA = new_instancemethod(_swigibpy.EWrapper_receiveFA, None, EWrapper)
EWrapper.historicalData = new_instancemethod(_swigibpy.EWrapper_historicalData, None, EWrapper)
EWrapper.scannerParameters = new_instancemethod(_swigibpy.EWrapper_scannerParameters, None, EWrapper)
EWrapper.scannerData = new_instancemethod(_swigibpy.EWrapper_scannerData, None, EWrapper)
EWrapper.scannerDataEnd = new_instancemethod(_swigibpy.EWrapper_scannerDataEnd, None, EWrapper)
EWrapper.realtimeBar = new_instancemethod(_swigibpy.EWrapper_realtimeBar, None, EWrapper)
EWrapper.currentTime = new_instancemethod(_swigibpy.EWrapper_currentTime, None, EWrapper)
EWrapper.fundamentalData = new_instancemethod(_swigibpy.EWrapper_fundamentalData, None, EWrapper)
EWrapper.deltaNeutralValidation = new_instancemethod(_swigibpy.EWrapper_deltaNeutralValidation, None, EWrapper)
EWrapper.tickSnapshotEnd = new_instancemethod(_swigibpy.EWrapper_tickSnapshotEnd, None, EWrapper)
EWrapper.marketDataType = new_instancemethod(_swigibpy.EWrapper_marketDataType, None, EWrapper)
EWrapper.commissionReport = new_instancemethod(_swigibpy.EWrapper_commissionReport, None, EWrapper)
EWrapper.position = new_instancemethod(_swigibpy.EWrapper_position, None, EWrapper)
EWrapper.positionEnd = new_instancemethod(_swigibpy.EWrapper_positionEnd, None, EWrapper)
EWrapper.accountSummary = new_instancemethod(_swigibpy.EWrapper_accountSummary, None, EWrapper)
EWrapper.accountSummaryEnd = new_instancemethod(_swigibpy.EWrapper_accountSummaryEnd, None, EWrapper)
EWrapper.verifyMessageAPI = new_instancemethod(_swigibpy.EWrapper_verifyMessageAPI, None, EWrapper)
EWrapper.verifyCompleted = new_instancemethod(_swigibpy.EWrapper_verifyCompleted, None, EWrapper)
EWrapper.displayGroupList = new_instancemethod(_swigibpy.EWrapper_displayGroupList, None, EWrapper)
EWrapper.displayGroupUpdated = new_instancemethod(_swigibpy.EWrapper_displayGroupUpdated, None, EWrapper)
EWrapper_swigregister = _swigibpy.EWrapper_swigregister
EWrapper_swigregister(EWrapper)



class EWrapperVerbose(EWrapper):
    '''Implements all EWrapper methods and prints to standard out when a method
    is invoked.
    '''

    def _print_call(self, name, *args, **kwargs):
        argspec = []
        if args:
            argspec.append(', '.join(str(a) for a in args))
        if kwargs:
            argspec.append(', '.join('%s=%s' for k, v in kwargs.items()))
        print('TWS call ignored - %s(%s)' % (name, ', '.join(argspec)))

class EWrapperQuiet(EWrapper):
    '''Implements all EWrapper methods and ignores method calls.'''

    def _ignore_call(self, *args, **kwargs):
        pass

def _make_printer(name):
    return lambda self, *a, **kw: self._print_call(name, *a, **kw)

for name, attr in EWrapper.__dict__.items():
    if name[0] == '_' or not callable(attr) or name in ('error', 'winError', 'pyError'):
        continue

    setattr(EWrapperQuiet, name, EWrapperQuiet.__dict__['_ignore_call'])
    setattr(EWrapperVerbose, name, _make_printer(name))