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


"""
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):
        self.__dict__[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(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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(self) -> PyObject"""
        return _swigibpy.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(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)

class ComboLegList(object):
    """Proxy of C++ std::vector<(p.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(self) -> SwigPyIterator"""
        return _swigibpy.ComboLegList_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _swigibpy.ComboLegList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _swigibpy.ComboLegList_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__getslice__(self, difference_type i, difference_type j) -> ComboLegList"""
        return _swigibpy.ComboLegList___getslice__(self, *args, **kwargs)

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

    def __delslice__(self, *args, **kwargs):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _swigibpy.ComboLegList___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _swigibpy.ComboLegList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> ComboLegList
        __getitem__(self, difference_type i) -> value_type
        """
        return _swigibpy.ComboLegList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, ComboLegList v)
        __setitem__(self, PySliceObject slice)
        __setitem__(self, difference_type i, value_type x)
        """
        return _swigibpy.ComboLegList___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """append(self, value_type x)"""
        return _swigibpy.ComboLegList_append(self, *args, **kwargs)

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

    def size(self):
        """size(self) -> size_type"""
        return _swigibpy.ComboLegList_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _swigibpy.ComboLegList_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _swigibpy.ComboLegList_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _swigibpy.ComboLegList_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _swigibpy.ComboLegList_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _swigibpy.ComboLegList_rend(self)

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

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _swigibpy.ComboLegList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> ComboLegList
        __init__(self, ComboLegList arg0) -> ComboLegList
        __init__(self, size_type size) -> ComboLegList
        __init__(self, size_type size, value_type value) -> ComboLegList
        """
        _swigibpy.ComboLegList_swiginit(self,_swigibpy.new_ComboLegList(*args))
    def push_back(self, *args, **kwargs):
        """push_back(self, value_type x)"""
        return _swigibpy.ComboLegList_push_back(self, *args, **kwargs)

    def front(self):
        """front(self) -> value_type"""
        return _swigibpy.ComboLegList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _swigibpy.ComboLegList_back(self)

    def assign(self, *args, **kwargs):
        """assign(self, size_type n, value_type x)"""
        return _swigibpy.ComboLegList_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _swigibpy.ComboLegList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _swigibpy.ComboLegList_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """reserve(self, size_type n)"""
        return _swigibpy.ComboLegList_reserve(self, *args, **kwargs)

    def capacity(self):
        """capacity(self) -> 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)

GROUPS = _swigibpy.GROUPS
PROFILES = _swigibpy.PROFILES
ALIASES = _swigibpy.ALIASES

def faDataTypeStr(*args, **kwargs):
  """faDataTypeStr(faDataType pFaDataType) -> char"""
  return _swigibpy.faDataTypeStr(*args, **kwargs)
REALTIME = _swigibpy.REALTIME
FROZEN = _swigibpy.FROZEN
SAME_POS = _swigibpy.SAME_POS
OPEN_POS = _swigibpy.OPEN_POS
CLOSE_POS = _swigibpy.CLOSE_POS
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__(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, *args, **kwargs):
        """__eq__(self, ComboLeg other) -> bool"""
        return _swigibpy.ComboLeg___eq__(self, *args, **kwargs)

    __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__(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__(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)
    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(*args, **kwargs):
        """CloneComboLegs(ComboLegList dst, ComboLegList src)"""
        return _swigibpy.Contract_CloneComboLegs(*args, **kwargs)

    CloneComboLegs = staticmethod(CloneComboLegs)
    def CleanupComboLegs(*args, **kwargs):
        """CleanupComboLegs(ComboLegList arg0)"""
        return _swigibpy.Contract_CleanupComboLegs(*args, **kwargs)

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

def Contract_CloneComboLegs(*args, **kwargs):
  """Contract_CloneComboLegs(ComboLegList dst, ComboLegList src)"""
  return _swigibpy.Contract_CloneComboLegs(*args, **kwargs)

def Contract_CleanupComboLegs(*args, **kwargs):
  """Contract_CleanupComboLegs(ComboLegList arg0)"""
  return _swigibpy.Contract_CleanupComboLegs(*args, **kwargs)

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__(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)
    tradingClass = _swig_property(_swigibpy.ContractDetails_tradingClass_get, _swigibpy.ContractDetails_tradingClass_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)
    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, *args, **kwargs):
        """eConnect(self, char host, unsigned int port, int clientId = 0) -> bool"""
        return _swigibpy.EClient_eConnect(self, *args, **kwargs)

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

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

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

    def reqMktData(self, *args, **kwargs):
        """
        reqMktData(self, TickerId id, Contract contract, IBString genericTicks, 
            bool snapshot)
        """
        return _swigibpy.EClient_reqMktData(self, *args, **kwargs)

    def cancelMktData(self, *args, **kwargs):
        """cancelMktData(self, TickerId id)"""
        return _swigibpy.EClient_cancelMktData(self, *args, **kwargs)

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

    def cancelOrder(self, *args, **kwargs):
        """cancelOrder(self, OrderId id)"""
        return _swigibpy.EClient_cancelOrder(self, *args, **kwargs)

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

    def reqAccountUpdates(self, *args, **kwargs):
        """reqAccountUpdates(self, bool subscribe, IBString acctCode)"""
        return _swigibpy.EClient_reqAccountUpdates(self, *args, **kwargs)

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

    def reqIds(self, *args, **kwargs):
        """reqIds(self, int numIds)"""
        return _swigibpy.EClient_reqIds(self, *args, **kwargs)

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

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

    def reqMktDepth(self, *args, **kwargs):
        """reqMktDepth(self, TickerId id, Contract contract, int numRows)"""
        return _swigibpy.EClient_reqMktDepth(self, *args, **kwargs)

    def cancelMktDepth(self, *args, **kwargs):
        """cancelMktDepth(self, TickerId id)"""
        return _swigibpy.EClient_cancelMktDepth(self, *args, **kwargs)

    def reqNewsBulletins(self, *args, **kwargs):
        """reqNewsBulletins(self, bool allMsgs)"""
        return _swigibpy.EClient_reqNewsBulletins(self, *args, **kwargs)

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

    def setServerLogLevel(self, *args, **kwargs):
        """setServerLogLevel(self, int level)"""
        return _swigibpy.EClient_setServerLogLevel(self, *args, **kwargs)

    def reqAutoOpenOrders(self, *args, **kwargs):
        """reqAutoOpenOrders(self, bool bAutoBind)"""
        return _swigibpy.EClient_reqAutoOpenOrders(self, *args, **kwargs)

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

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

    def requestFA(self, *args, **kwargs):
        """requestFA(self, faDataType pFaDataType)"""
        return _swigibpy.EClient_requestFA(self, *args, **kwargs)

    def replaceFA(self, *args, **kwargs):
        """replaceFA(self, faDataType pFaDataType, IBString cxml)"""
        return _swigibpy.EClient_replaceFA(self, *args, **kwargs)

    def reqHistoricalData(self, *args, **kwargs):
        """
        reqHistoricalData(self, TickerId id, Contract contract, IBString endDateTime, 
            IBString durationStr, IBString barSizeSetting, 
            IBString whatToShow, int useRTH, int formatDate)
        """
        return _swigibpy.EClient_reqHistoricalData(self, *args, **kwargs)

    def exerciseOptions(self, *args, **kwargs):
        """
        exerciseOptions(self, TickerId id, Contract contract, int exerciseAction, 
            int exerciseQuantity, IBString account, int override)
        """
        return _swigibpy.EClient_exerciseOptions(self, *args, **kwargs)

    def cancelHistoricalData(self, *args, **kwargs):
        """cancelHistoricalData(self, TickerId tickerId)"""
        return _swigibpy.EClient_cancelHistoricalData(self, *args, **kwargs)

    def reqRealTimeBars(self, *args, **kwargs):
        """
        reqRealTimeBars(self, TickerId id, Contract contract, int barSize, IBString whatToShow, 
            bool useRTH)
        """
        return _swigibpy.EClient_reqRealTimeBars(self, *args, **kwargs)

    def cancelRealTimeBars(self, *args, **kwargs):
        """cancelRealTimeBars(self, TickerId tickerId)"""
        return _swigibpy.EClient_cancelRealTimeBars(self, *args, **kwargs)

    def cancelScannerSubscription(self, *args, **kwargs):
        """cancelScannerSubscription(self, int tickerId)"""
        return _swigibpy.EClient_cancelScannerSubscription(self, *args, **kwargs)

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

    def reqScannerSubscription(self, *args, **kwargs):
        """reqScannerSubscription(self, int tickerId, ScannerSubscription subscription)"""
        return _swigibpy.EClient_reqScannerSubscription(self, *args, **kwargs)

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

    def reqFundamentalData(self, *args, **kwargs):
        """reqFundamentalData(self, TickerId reqId, Contract arg1, IBString reportType)"""
        return _swigibpy.EClient_reqFundamentalData(self, *args, **kwargs)

    def cancelFundamentalData(self, *args, **kwargs):
        """cancelFundamentalData(self, TickerId reqId)"""
        return _swigibpy.EClient_cancelFundamentalData(self, *args, **kwargs)

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

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

    def cancelCalculateImpliedVolatility(self, *args, **kwargs):
        """cancelCalculateImpliedVolatility(self, TickerId reqId)"""
        return _swigibpy.EClient_cancelCalculateImpliedVolatility(self, *args, **kwargs)

    def cancelCalculateOptionPrice(self, *args, **kwargs):
        """cancelCalculateOptionPrice(self, TickerId reqId)"""
        return _swigibpy.EClient_cancelCalculateOptionPrice(self, *args, **kwargs)

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

    def reqMarketDataType(self, *args, **kwargs):
        """reqMarketDataType(self, int marketDataType)"""
        return _swigibpy.EClient_reqMarketDataType(self, *args, **kwargs)

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_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, *args, **kwargs):
        """eConnect(self, char host, unsigned int port, int clientId = 0) -> bool"""
        return _swigibpy.EClientSocketBase_eConnect(self, *args, **kwargs)

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

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

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

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

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

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

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

    def reqMktData(self, *args, **kwargs):
        """
        reqMktData(self, TickerId id, Contract contract, IBString genericTicks, 
            bool snapshot)
        """
        return _swigibpy.EClientSocketBase_reqMktData(self, *args, **kwargs)

    def cancelMktData(self, *args, **kwargs):
        """cancelMktData(self, TickerId id)"""
        return _swigibpy.EClientSocketBase_cancelMktData(self, *args, **kwargs)

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

    def cancelOrder(self, *args, **kwargs):
        """cancelOrder(self, OrderId id)"""
        return _swigibpy.EClientSocketBase_cancelOrder(self, *args, **kwargs)

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

    def reqAccountUpdates(self, *args, **kwargs):
        """reqAccountUpdates(self, bool subscribe, IBString acctCode)"""
        return _swigibpy.EClientSocketBase_reqAccountUpdates(self, *args, **kwargs)

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

    def reqIds(self, *args, **kwargs):
        """reqIds(self, int numIds)"""
        return _swigibpy.EClientSocketBase_reqIds(self, *args, **kwargs)

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

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

    def reqMktDepth(self, *args, **kwargs):
        """reqMktDepth(self, TickerId tickerId, Contract contract, int numRows)"""
        return _swigibpy.EClientSocketBase_reqMktDepth(self, *args, **kwargs)

    def cancelMktDepth(self, *args, **kwargs):
        """cancelMktDepth(self, TickerId tickerId)"""
        return _swigibpy.EClientSocketBase_cancelMktDepth(self, *args, **kwargs)

    def reqNewsBulletins(self, *args, **kwargs):
        """reqNewsBulletins(self, bool allMsgs)"""
        return _swigibpy.EClientSocketBase_reqNewsBulletins(self, *args, **kwargs)

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

    def setServerLogLevel(self, *args, **kwargs):
        """setServerLogLevel(self, int level)"""
        return _swigibpy.EClientSocketBase_setServerLogLevel(self, *args, **kwargs)

    def reqAutoOpenOrders(self, *args, **kwargs):
        """reqAutoOpenOrders(self, bool bAutoBind)"""
        return _swigibpy.EClientSocketBase_reqAutoOpenOrders(self, *args, **kwargs)

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

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

    def requestFA(self, *args, **kwargs):
        """requestFA(self, faDataType pFaDataType)"""
        return _swigibpy.EClientSocketBase_requestFA(self, *args, **kwargs)

    def replaceFA(self, *args, **kwargs):
        """replaceFA(self, faDataType pFaDataType, IBString cxml)"""
        return _swigibpy.EClientSocketBase_replaceFA(self, *args, **kwargs)

    def reqHistoricalData(self, *args, **kwargs):
        """
        reqHistoricalData(self, TickerId id, Contract contract, IBString endDateTime, 
            IBString durationStr, IBString barSizeSetting, 
            IBString whatToShow, int useRTH, int formatDate)
        """
        return _swigibpy.EClientSocketBase_reqHistoricalData(self, *args, **kwargs)

    def exerciseOptions(self, *args, **kwargs):
        """
        exerciseOptions(self, TickerId tickerId, Contract contract, int exerciseAction, 
            int exerciseQuantity, IBString account, 
            int override)
        """
        return _swigibpy.EClientSocketBase_exerciseOptions(self, *args, **kwargs)

    def cancelHistoricalData(self, *args, **kwargs):
        """cancelHistoricalData(self, TickerId tickerId)"""
        return _swigibpy.EClientSocketBase_cancelHistoricalData(self, *args, **kwargs)

    def reqRealTimeBars(self, *args, **kwargs):
        """
        reqRealTimeBars(self, TickerId id, Contract contract, int barSize, IBString whatToShow, 
            bool useRTH)
        """
        return _swigibpy.EClientSocketBase_reqRealTimeBars(self, *args, **kwargs)

    def cancelRealTimeBars(self, *args, **kwargs):
        """cancelRealTimeBars(self, TickerId tickerId)"""
        return _swigibpy.EClientSocketBase_cancelRealTimeBars(self, *args, **kwargs)

    def cancelScannerSubscription(self, *args, **kwargs):
        """cancelScannerSubscription(self, int tickerId)"""
        return _swigibpy.EClientSocketBase_cancelScannerSubscription(self, *args, **kwargs)

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

    def reqScannerSubscription(self, *args, **kwargs):
        """reqScannerSubscription(self, int tickerId, ScannerSubscription subscription)"""
        return _swigibpy.EClientSocketBase_reqScannerSubscription(self, *args, **kwargs)

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

    def reqFundamentalData(self, *args, **kwargs):
        """reqFundamentalData(self, TickerId reqId, Contract arg1, IBString reportType)"""
        return _swigibpy.EClientSocketBase_reqFundamentalData(self, *args, **kwargs)

    def cancelFundamentalData(self, *args, **kwargs):
        """cancelFundamentalData(self, TickerId reqId)"""
        return _swigibpy.EClientSocketBase_cancelFundamentalData(self, *args, **kwargs)

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

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

    def cancelCalculateImpliedVolatility(self, *args, **kwargs):
        """cancelCalculateImpliedVolatility(self, TickerId reqId)"""
        return _swigibpy.EClientSocketBase_cancelCalculateImpliedVolatility(self, *args, **kwargs)

    def cancelCalculateOptionPrice(self, *args, **kwargs):
        """cancelCalculateOptionPrice(self, TickerId reqId)"""
        return _swigibpy.EClientSocketBase_cancelCalculateOptionPrice(self, *args, **kwargs)

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

    def reqMarketDataType(self, *args, **kwargs):
        """reqMarketDataType(self, int marketDataType)"""
        return _swigibpy.EClientSocketBase_reqMarketDataType(self, *args, **kwargs)

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_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__(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)
    __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__(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)

CUSTOMER = _swigibpy.CUSTOMER
FIRM = _swigibpy.FIRM
UNKNOWN = _swigibpy.UNKNOWN
AUCTION_UNSET = _swigibpy.AUCTION_UNSET
AUCTION_MATCH = _swigibpy.AUCTION_MATCH
AUCTION_IMPROVEMENT = _swigibpy.AUCTION_IMPROVEMENT
AUCTION_TRANSPARENT = _swigibpy.AUCTION_TRANSPARENT
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__(self) -> TagValue
        __init__(self, IBString p_tag, IBString 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 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__(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)
    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)
    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)
    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)
    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)
    __swig_destroy__ = _swigibpy.delete_Order
Order_swigregister = _swigibpy.Order_swigregister
Order_swigregister(Order)

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

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

import threading
class TWSPoller(threading.Thread):
    '''Polls TWS every second for any outstanding messages'''

    def __init__(self, tws, poll_interval=0.5):
        super(TWSPoller, self).__init__()
        self.daemon = True
        self._tws = tws
        self._poll_interval = poll_interval
        self.stop_event = threading.Event()

    def run(self):
        '''Continually poll TWS until the stop flag is set'''
        while not self.stop_event.is_set():
            try:
                self._tws.checkMessages()
            except:
                if self.stop_event.is_set():
                    break
                else:
                    raise
            self.stop_event.wait(self._poll_interval)

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, *args, **kwargs): 
        """__init__(self, EWrapper ptr) -> EPosixClientSocket"""
        _swigibpy.EPosixClientSocket_swiginit(self,_swigibpy.new_EPosixClientSocket(*args, **kwargs))
    __swig_destroy__ = _swigibpy.delete_EPosixClientSocket
    def eConnect(self, *args, **kwargs):
        """eConnect(self, char host, unsigned int port, int clientId = 0) -> bool"""
        poll_interval = kwargs.pop('poll_interval', 0.5)


        val = _swigibpy.EPosixClientSocket_eConnect(self, *args, **kwargs)
        if val:
            self.poller = TWSPoller(self, poll_interval=poll_interval)
            self.poller.start()


        return val

    def eDisconnect(self):
        """eDisconnect(self)"""
        if self.poller:
            self.poller.stop_event.set()
            self.poller = None


        return _swigibpy.EPosixClientSocket_eDisconnect(self)

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

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

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

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

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

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

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)

class TWSError(Exception):
    '''Exception raised during communication with Interactive Brokers TWS
    application
    '''

    def __init__(self, code, msg):
        self.code = code
        self.msg = msg

    def __str__(self):
        return "%s: %s" % (self.code, repr(self.msg))

class TWSSystemError(TWSError):
    '''System related exception raised during communication with Interactive
    Brokers TWS application.
    '''
    pass

class TWSClientError(TWSError):
    '''Exception raised on client (python) side by Interactive Brokers API'''
    pass

BID_SIZE = _swigibpy.BID_SIZE
BID = _swigibpy.BID
ASK = _swigibpy.ASK
ASK_SIZE = _swigibpy.ASK_SIZE
LAST = _swigibpy.LAST
LAST_SIZE = _swigibpy.LAST_SIZE
HIGH = _swigibpy.HIGH
LOW = _swigibpy.LOW
VOLUME = _swigibpy.VOLUME
CLOSE = _swigibpy.CLOSE
BID_OPTION_COMPUTATION = _swigibpy.BID_OPTION_COMPUTATION
ASK_OPTION_COMPUTATION = _swigibpy.ASK_OPTION_COMPUTATION
LAST_OPTION_COMPUTATION = _swigibpy.LAST_OPTION_COMPUTATION
MODEL_OPTION = _swigibpy.MODEL_OPTION
OPEN = _swigibpy.OPEN
LOW_13_WEEK = _swigibpy.LOW_13_WEEK
HIGH_13_WEEK = _swigibpy.HIGH_13_WEEK
LOW_26_WEEK = _swigibpy.LOW_26_WEEK
HIGH_26_WEEK = _swigibpy.HIGH_26_WEEK
LOW_52_WEEK = _swigibpy.LOW_52_WEEK
HIGH_52_WEEK = _swigibpy.HIGH_52_WEEK
AVG_VOLUME = _swigibpy.AVG_VOLUME
OPEN_INTEREST = _swigibpy.OPEN_INTEREST
OPTION_HISTORICAL_VOL = _swigibpy.OPTION_HISTORICAL_VOL
OPTION_IMPLIED_VOL = _swigibpy.OPTION_IMPLIED_VOL
OPTION_BID_EXCH = _swigibpy.OPTION_BID_EXCH
OPTION_ASK_EXCH = _swigibpy.OPTION_ASK_EXCH
OPTION_CALL_OPEN_INTEREST = _swigibpy.OPTION_CALL_OPEN_INTEREST
OPTION_PUT_OPEN_INTEREST = _swigibpy.OPTION_PUT_OPEN_INTEREST
OPTION_CALL_VOLUME = _swigibpy.OPTION_CALL_VOLUME
OPTION_PUT_VOLUME = _swigibpy.OPTION_PUT_VOLUME
INDEX_FUTURE_PREMIUM = _swigibpy.INDEX_FUTURE_PREMIUM
BID_EXCH = _swigibpy.BID_EXCH
ASK_EXCH = _swigibpy.ASK_EXCH
AUCTION_VOLUME = _swigibpy.AUCTION_VOLUME
AUCTION_PRICE = _swigibpy.AUCTION_PRICE
AUCTION_IMBALANCE = _swigibpy.AUCTION_IMBALANCE
MARK_PRICE = _swigibpy.MARK_PRICE
BID_EFP_COMPUTATION = _swigibpy.BID_EFP_COMPUTATION
ASK_EFP_COMPUTATION = _swigibpy.ASK_EFP_COMPUTATION
LAST_EFP_COMPUTATION = _swigibpy.LAST_EFP_COMPUTATION
OPEN_EFP_COMPUTATION = _swigibpy.OPEN_EFP_COMPUTATION
HIGH_EFP_COMPUTATION = _swigibpy.HIGH_EFP_COMPUTATION
LOW_EFP_COMPUTATION = _swigibpy.LOW_EFP_COMPUTATION
CLOSE_EFP_COMPUTATION = _swigibpy.CLOSE_EFP_COMPUTATION
LAST_TIMESTAMP = _swigibpy.LAST_TIMESTAMP
SHORTABLE = _swigibpy.SHORTABLE
FUNDAMENTAL_RATIOS = _swigibpy.FUNDAMENTAL_RATIOS
RT_VOLUME = _swigibpy.RT_VOLUME
HALTED = _swigibpy.HALTED
BID_YIELD = _swigibpy.BID_YIELD
ASK_YIELD = _swigibpy.ASK_YIELD
LAST_YIELD = _swigibpy.LAST_YIELD
CUST_OPTION_COMPUTATION = _swigibpy.CUST_OPTION_COMPUTATION
TRADE_COUNT = _swigibpy.TRADE_COUNT
TRADE_RATE = _swigibpy.TRADE_RATE
VOLUME_RATE = _swigibpy.VOLUME_RATE
LAST_RTH_TRADE = _swigibpy.LAST_RTH_TRADE
NOT_SET = _swigibpy.NOT_SET

def isPrice(*args, **kwargs):
  """isPrice(TickType tickType) -> bool"""
  return _swigibpy.isPrice(*args, **kwargs)
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, *args, **kwargs):
        """tickPrice(self, TickerId tickerId, TickType field, double price, int canAutoExecute)"""
        return _swigibpy.EWrapper_tickPrice(self, *args, **kwargs)

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

    def tickOptionComputation(self, *args, **kwargs):
        """
        tickOptionComputation(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, *args, **kwargs)

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

    def tickString(self, *args, **kwargs):
        """tickString(self, TickerId tickerId, TickType tickType, IBString value)"""
        return _swigibpy.EWrapper_tickString(self, *args, **kwargs)

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

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

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

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

    def winError(self, str, lastError):
        '''Error in TWS API library'''

        raise TWSClientError(lastError, str)


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

    def updateAccountValue(self, *args, **kwargs):
        """updateAccountValue(self, IBString key, IBString val, IBString currency, IBString accountName)"""
        return _swigibpy.EWrapper_updateAccountValue(self, *args, **kwargs)

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

    def updateAccountTime(self, *args, **kwargs):
        """updateAccountTime(self, IBString timeStamp)"""
        return _swigibpy.EWrapper_updateAccountTime(self, *args, **kwargs)

    def accountDownloadEnd(self, *args, **kwargs):
        """accountDownloadEnd(self, IBString accountName)"""
        return _swigibpy.EWrapper_accountDownloadEnd(self, *args, **kwargs)

    def nextValidId(self, *args, **kwargs):
        """nextValidId(self, OrderId orderId)"""
        return _swigibpy.EWrapper_nextValidId(self, *args, **kwargs)

    def contractDetails(self, *args, **kwargs):
        """contractDetails(self, int reqId, ContractDetails contractDetails)"""
        return _swigibpy.EWrapper_contractDetails(self, *args, **kwargs)

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

    def contractDetailsEnd(self, *args, **kwargs):
        """contractDetailsEnd(self, int reqId)"""
        return _swigibpy.EWrapper_contractDetailsEnd(self, *args, **kwargs)

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

    def execDetailsEnd(self, *args, **kwargs):
        """execDetailsEnd(self, int reqId)"""
        return _swigibpy.EWrapper_execDetailsEnd(self, *args, **kwargs)

    def error(self, id, errorCode, errorString):
        '''Error during communication with TWS'''

        if errorCode == 165:
            print("TWS Message %s: %s" % (errorCode, errorString))
        elif errorCode >= 100 and errorCode < 1100:
            raise TWSError(errorCode, errorString)
        elif  errorCode >= 1100 and errorCode < 2100:
            raise TWSSystemError(errorCode, errorString)
        elif errorCode >= 2100 and errorCode < 2110:
            import sys
            sys.stderr.write("TWS Warning %s: %s\n" % (errorCode, errorString))
        else:
            raise RuntimeError(errorCode, errorString)


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

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

    def updateNewsBulletin(self, *args, **kwargs):
        """updateNewsBulletin(self, int msgId, int msgType, IBString newsMessage, IBString originExch)"""
        return _swigibpy.EWrapper_updateNewsBulletin(self, *args, **kwargs)

    def managedAccounts(self, *args, **kwargs):
        """managedAccounts(self, IBString accountsList)"""
        return _swigibpy.EWrapper_managedAccounts(self, *args, **kwargs)

    def receiveFA(self, *args, **kwargs):
        """receiveFA(self, faDataType pFaDataType, IBString cxml)"""
        return _swigibpy.EWrapper_receiveFA(self, *args, **kwargs)

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

    def scannerParameters(self, *args, **kwargs):
        """scannerParameters(self, IBString xml)"""
        return _swigibpy.EWrapper_scannerParameters(self, *args, **kwargs)

    def scannerData(self, *args, **kwargs):
        """
        scannerData(self, int reqId, int rank, ContractDetails contractDetails, 
            IBString distance, IBString benchmark, IBString projection, 
            IBString legsStr)
        """
        return _swigibpy.EWrapper_scannerData(self, *args, **kwargs)

    def scannerDataEnd(self, *args, **kwargs):
        """scannerDataEnd(self, int reqId)"""
        return _swigibpy.EWrapper_scannerDataEnd(self, *args, **kwargs)

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

    def currentTime(self, *args, **kwargs):
        """currentTime(self, long time)"""
        return _swigibpy.EWrapper_currentTime(self, *args, **kwargs)

    def fundamentalData(self, *args, **kwargs):
        """fundamentalData(self, TickerId reqId, IBString data)"""
        return _swigibpy.EWrapper_fundamentalData(self, *args, **kwargs)

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

    def tickSnapshotEnd(self, *args, **kwargs):
        """tickSnapshotEnd(self, int reqId)"""
        return _swigibpy.EWrapper_tickSnapshotEnd(self, *args, **kwargs)

    def marketDataType(self, *args, **kwargs):
        """marketDataType(self, TickerId reqId, int marketDataType)"""
        return _swigibpy.EWrapper_marketDataType(self, *args, **kwargs)

    def __init__(self): 
        """__init__(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_swigregister = _swigibpy.EWrapper_swigregister
EWrapper_swigregister(EWrapper)



