/usr/lib/python2.7/dist-packages/ftdi1.py

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




"""Python interface to libftdi1"""


from sys import version_info
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('_ftdi1', [dirname(__file__)])
        except ImportError:
            import _ftdi1
            return _ftdi1
        if fp is not None:
            try:
                _mod = imp.load_module('_ftdi1', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ftdi1 = swig_import_helper()
    del swig_import_helper
else:
    import _ftdi1
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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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_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 Exception:
        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 usb_find_all(ftdi, vendor, product):
    """usb_find_all(context, vendor, product) -> (return_code, devlist)"""
    return _ftdi1.usb_find_all(ftdi, vendor, product)

def usb_get_strings(*args):
    """usb_get_strings(context, device) -> (return_code, manufacturer, description, serial)"""
    return _ftdi1.usb_get_strings(*args)

def read_data(ftdi, buf):
    """read_data(context) -> (return_code, buf)"""
    return _ftdi1.read_data(ftdi, buf)

def read_data_get_chunksize(ftdi):
    """read_data_get_chunksize(context ftdi) -> int"""
    return _ftdi1.read_data_get_chunksize(ftdi)

def write_data_get_chunksize(ftdi):
    """write_data_get_chunksize(context ftdi) -> int"""
    return _ftdi1.write_data_get_chunksize(ftdi)

def read_pins(ftdi):
    """read_pins(context) -> (return_code, pins)"""
    return _ftdi1.read_pins(ftdi)

def get_latency_timer(ftdi):
    """get_latency_timer(context ftdi) -> int"""
    return _ftdi1.get_latency_timer(ftdi)

def poll_modem_status(ftdi):
    """poll_modem_status(context ftdi) -> int"""
    return _ftdi1.poll_modem_status(ftdi)

def get_eeprom_value(ftdi, value_name):
    """get_eeprom_value(context ftdi, enum ftdi_eeprom_value value_name) -> int"""
    return _ftdi1.get_eeprom_value(ftdi, value_name)

def get_eeprom_buf(ftdi, buf):
    """get_eeprom_buf(context ftdi, unsigned char * buf) -> int"""
    return _ftdi1.get_eeprom_buf(ftdi, buf)

def read_eeprom_location(ftdi, eeprom_addr):
    """read_eeprom_location(context, eeprom_addr) -> (return_code, eeprom_val)"""
    return _ftdi1.read_eeprom_location(ftdi, eeprom_addr)

def read_chipid(ftdi):
    """ftdi_read_chipid(context) -> (return_code, chipid)"""
    return _ftdi1.read_chipid(ftdi)

_ftdi1.TYPE_AM_swigconstant(_ftdi1)
TYPE_AM = _ftdi1.TYPE_AM

_ftdi1.TYPE_BM_swigconstant(_ftdi1)
TYPE_BM = _ftdi1.TYPE_BM

_ftdi1.TYPE_2232C_swigconstant(_ftdi1)
TYPE_2232C = _ftdi1.TYPE_2232C

_ftdi1.TYPE_R_swigconstant(_ftdi1)
TYPE_R = _ftdi1.TYPE_R

_ftdi1.TYPE_2232H_swigconstant(_ftdi1)
TYPE_2232H = _ftdi1.TYPE_2232H

_ftdi1.TYPE_4232H_swigconstant(_ftdi1)
TYPE_4232H = _ftdi1.TYPE_4232H

_ftdi1.TYPE_232H_swigconstant(_ftdi1)
TYPE_232H = _ftdi1.TYPE_232H

_ftdi1.TYPE_230X_swigconstant(_ftdi1)
TYPE_230X = _ftdi1.TYPE_230X

_ftdi1.NONE_swigconstant(_ftdi1)
NONE = _ftdi1.NONE

_ftdi1.ODD_swigconstant(_ftdi1)
ODD = _ftdi1.ODD

_ftdi1.EVEN_swigconstant(_ftdi1)
EVEN = _ftdi1.EVEN

_ftdi1.MARK_swigconstant(_ftdi1)
MARK = _ftdi1.MARK

_ftdi1.SPACE_swigconstant(_ftdi1)
SPACE = _ftdi1.SPACE

_ftdi1.STOP_BIT_1_swigconstant(_ftdi1)
STOP_BIT_1 = _ftdi1.STOP_BIT_1

_ftdi1.STOP_BIT_15_swigconstant(_ftdi1)
STOP_BIT_15 = _ftdi1.STOP_BIT_15

_ftdi1.STOP_BIT_2_swigconstant(_ftdi1)
STOP_BIT_2 = _ftdi1.STOP_BIT_2

_ftdi1.BITS_7_swigconstant(_ftdi1)
BITS_7 = _ftdi1.BITS_7

_ftdi1.BITS_8_swigconstant(_ftdi1)
BITS_8 = _ftdi1.BITS_8

_ftdi1.BREAK_OFF_swigconstant(_ftdi1)
BREAK_OFF = _ftdi1.BREAK_OFF

_ftdi1.BREAK_ON_swigconstant(_ftdi1)
BREAK_ON = _ftdi1.BREAK_ON

_ftdi1.BITMODE_RESET_swigconstant(_ftdi1)
BITMODE_RESET = _ftdi1.BITMODE_RESET

_ftdi1.BITMODE_BITBANG_swigconstant(_ftdi1)
BITMODE_BITBANG = _ftdi1.BITMODE_BITBANG

_ftdi1.BITMODE_MPSSE_swigconstant(_ftdi1)
BITMODE_MPSSE = _ftdi1.BITMODE_MPSSE

_ftdi1.BITMODE_SYNCBB_swigconstant(_ftdi1)
BITMODE_SYNCBB = _ftdi1.BITMODE_SYNCBB

_ftdi1.BITMODE_MCU_swigconstant(_ftdi1)
BITMODE_MCU = _ftdi1.BITMODE_MCU

_ftdi1.BITMODE_OPTO_swigconstant(_ftdi1)
BITMODE_OPTO = _ftdi1.BITMODE_OPTO

_ftdi1.BITMODE_CBUS_swigconstant(_ftdi1)
BITMODE_CBUS = _ftdi1.BITMODE_CBUS

_ftdi1.BITMODE_SYNCFF_swigconstant(_ftdi1)
BITMODE_SYNCFF = _ftdi1.BITMODE_SYNCFF

_ftdi1.BITMODE_FT1284_swigconstant(_ftdi1)
BITMODE_FT1284 = _ftdi1.BITMODE_FT1284

_ftdi1.INTERFACE_ANY_swigconstant(_ftdi1)
INTERFACE_ANY = _ftdi1.INTERFACE_ANY

_ftdi1.INTERFACE_A_swigconstant(_ftdi1)
INTERFACE_A = _ftdi1.INTERFACE_A

_ftdi1.INTERFACE_B_swigconstant(_ftdi1)
INTERFACE_B = _ftdi1.INTERFACE_B

_ftdi1.INTERFACE_C_swigconstant(_ftdi1)
INTERFACE_C = _ftdi1.INTERFACE_C

_ftdi1.INTERFACE_D_swigconstant(_ftdi1)
INTERFACE_D = _ftdi1.INTERFACE_D

_ftdi1.AUTO_DETACH_SIO_MODULE_swigconstant(_ftdi1)
AUTO_DETACH_SIO_MODULE = _ftdi1.AUTO_DETACH_SIO_MODULE

_ftdi1.DONT_DETACH_SIO_MODULE_swigconstant(_ftdi1)
DONT_DETACH_SIO_MODULE = _ftdi1.DONT_DETACH_SIO_MODULE

_ftdi1.MPSSE_WRITE_NEG_swigconstant(_ftdi1)
MPSSE_WRITE_NEG = _ftdi1.MPSSE_WRITE_NEG

_ftdi1.MPSSE_BITMODE_swigconstant(_ftdi1)
MPSSE_BITMODE = _ftdi1.MPSSE_BITMODE

_ftdi1.MPSSE_READ_NEG_swigconstant(_ftdi1)
MPSSE_READ_NEG = _ftdi1.MPSSE_READ_NEG

_ftdi1.MPSSE_LSB_swigconstant(_ftdi1)
MPSSE_LSB = _ftdi1.MPSSE_LSB

_ftdi1.MPSSE_DO_WRITE_swigconstant(_ftdi1)
MPSSE_DO_WRITE = _ftdi1.MPSSE_DO_WRITE

_ftdi1.MPSSE_DO_READ_swigconstant(_ftdi1)
MPSSE_DO_READ = _ftdi1.MPSSE_DO_READ

_ftdi1.MPSSE_WRITE_TMS_swigconstant(_ftdi1)
MPSSE_WRITE_TMS = _ftdi1.MPSSE_WRITE_TMS

_ftdi1.SET_BITS_LOW_swigconstant(_ftdi1)
SET_BITS_LOW = _ftdi1.SET_BITS_LOW

_ftdi1.SET_BITS_HIGH_swigconstant(_ftdi1)
SET_BITS_HIGH = _ftdi1.SET_BITS_HIGH

_ftdi1.GET_BITS_LOW_swigconstant(_ftdi1)
GET_BITS_LOW = _ftdi1.GET_BITS_LOW

_ftdi1.GET_BITS_HIGH_swigconstant(_ftdi1)
GET_BITS_HIGH = _ftdi1.GET_BITS_HIGH

_ftdi1.LOOPBACK_START_swigconstant(_ftdi1)
LOOPBACK_START = _ftdi1.LOOPBACK_START

_ftdi1.LOOPBACK_END_swigconstant(_ftdi1)
LOOPBACK_END = _ftdi1.LOOPBACK_END

_ftdi1.TCK_DIVISOR_swigconstant(_ftdi1)
TCK_DIVISOR = _ftdi1.TCK_DIVISOR

_ftdi1.DIS_DIV_5_swigconstant(_ftdi1)
DIS_DIV_5 = _ftdi1.DIS_DIV_5

_ftdi1.EN_DIV_5_swigconstant(_ftdi1)
EN_DIV_5 = _ftdi1.EN_DIV_5

_ftdi1.EN_3_PHASE_swigconstant(_ftdi1)
EN_3_PHASE = _ftdi1.EN_3_PHASE

_ftdi1.DIS_3_PHASE_swigconstant(_ftdi1)
DIS_3_PHASE = _ftdi1.DIS_3_PHASE

_ftdi1.CLK_BITS_swigconstant(_ftdi1)
CLK_BITS = _ftdi1.CLK_BITS

_ftdi1.CLK_BYTES_swigconstant(_ftdi1)
CLK_BYTES = _ftdi1.CLK_BYTES

_ftdi1.CLK_WAIT_HIGH_swigconstant(_ftdi1)
CLK_WAIT_HIGH = _ftdi1.CLK_WAIT_HIGH

_ftdi1.CLK_WAIT_LOW_swigconstant(_ftdi1)
CLK_WAIT_LOW = _ftdi1.CLK_WAIT_LOW

_ftdi1.EN_ADAPTIVE_swigconstant(_ftdi1)
EN_ADAPTIVE = _ftdi1.EN_ADAPTIVE

_ftdi1.DIS_ADAPTIVE_swigconstant(_ftdi1)
DIS_ADAPTIVE = _ftdi1.DIS_ADAPTIVE

_ftdi1.CLK_BYTES_OR_HIGH_swigconstant(_ftdi1)
CLK_BYTES_OR_HIGH = _ftdi1.CLK_BYTES_OR_HIGH

_ftdi1.CLK_BYTES_OR_LOW_swigconstant(_ftdi1)
CLK_BYTES_OR_LOW = _ftdi1.CLK_BYTES_OR_LOW

_ftdi1.DRIVE_OPEN_COLLECTOR_swigconstant(_ftdi1)
DRIVE_OPEN_COLLECTOR = _ftdi1.DRIVE_OPEN_COLLECTOR

_ftdi1.SEND_IMMEDIATE_swigconstant(_ftdi1)
SEND_IMMEDIATE = _ftdi1.SEND_IMMEDIATE

_ftdi1.WAIT_ON_HIGH_swigconstant(_ftdi1)
WAIT_ON_HIGH = _ftdi1.WAIT_ON_HIGH

_ftdi1.WAIT_ON_LOW_swigconstant(_ftdi1)
WAIT_ON_LOW = _ftdi1.WAIT_ON_LOW

_ftdi1.READ_SHORT_swigconstant(_ftdi1)
READ_SHORT = _ftdi1.READ_SHORT

_ftdi1.READ_EXTENDED_swigconstant(_ftdi1)
READ_EXTENDED = _ftdi1.READ_EXTENDED

_ftdi1.WRITE_SHORT_swigconstant(_ftdi1)
WRITE_SHORT = _ftdi1.WRITE_SHORT

_ftdi1.WRITE_EXTENDED_swigconstant(_ftdi1)
WRITE_EXTENDED = _ftdi1.WRITE_EXTENDED

_ftdi1.SIO_RESET_swigconstant(_ftdi1)
SIO_RESET = _ftdi1.SIO_RESET

_ftdi1.SIO_MODEM_CTRL_swigconstant(_ftdi1)
SIO_MODEM_CTRL = _ftdi1.SIO_MODEM_CTRL

_ftdi1.SIO_SET_FLOW_CTRL_swigconstant(_ftdi1)
SIO_SET_FLOW_CTRL = _ftdi1.SIO_SET_FLOW_CTRL

_ftdi1.SIO_SET_BAUD_RATE_swigconstant(_ftdi1)
SIO_SET_BAUD_RATE = _ftdi1.SIO_SET_BAUD_RATE

_ftdi1.SIO_SET_DATA_swigconstant(_ftdi1)
SIO_SET_DATA = _ftdi1.SIO_SET_DATA

_ftdi1.SIO_RESET_REQUEST_swigconstant(_ftdi1)
SIO_RESET_REQUEST = _ftdi1.SIO_RESET_REQUEST

_ftdi1.SIO_SET_BAUDRATE_REQUEST_swigconstant(_ftdi1)
SIO_SET_BAUDRATE_REQUEST = _ftdi1.SIO_SET_BAUDRATE_REQUEST

_ftdi1.SIO_SET_DATA_REQUEST_swigconstant(_ftdi1)
SIO_SET_DATA_REQUEST = _ftdi1.SIO_SET_DATA_REQUEST

_ftdi1.SIO_SET_FLOW_CTRL_REQUEST_swigconstant(_ftdi1)
SIO_SET_FLOW_CTRL_REQUEST = _ftdi1.SIO_SET_FLOW_CTRL_REQUEST

_ftdi1.SIO_SET_MODEM_CTRL_REQUEST_swigconstant(_ftdi1)
SIO_SET_MODEM_CTRL_REQUEST = _ftdi1.SIO_SET_MODEM_CTRL_REQUEST

_ftdi1.SIO_POLL_MODEM_STATUS_REQUEST_swigconstant(_ftdi1)
SIO_POLL_MODEM_STATUS_REQUEST = _ftdi1.SIO_POLL_MODEM_STATUS_REQUEST

_ftdi1.SIO_SET_EVENT_CHAR_REQUEST_swigconstant(_ftdi1)
SIO_SET_EVENT_CHAR_REQUEST = _ftdi1.SIO_SET_EVENT_CHAR_REQUEST

_ftdi1.SIO_SET_ERROR_CHAR_REQUEST_swigconstant(_ftdi1)
SIO_SET_ERROR_CHAR_REQUEST = _ftdi1.SIO_SET_ERROR_CHAR_REQUEST

_ftdi1.SIO_SET_LATENCY_TIMER_REQUEST_swigconstant(_ftdi1)
SIO_SET_LATENCY_TIMER_REQUEST = _ftdi1.SIO_SET_LATENCY_TIMER_REQUEST

_ftdi1.SIO_GET_LATENCY_TIMER_REQUEST_swigconstant(_ftdi1)
SIO_GET_LATENCY_TIMER_REQUEST = _ftdi1.SIO_GET_LATENCY_TIMER_REQUEST

_ftdi1.SIO_SET_BITMODE_REQUEST_swigconstant(_ftdi1)
SIO_SET_BITMODE_REQUEST = _ftdi1.SIO_SET_BITMODE_REQUEST

_ftdi1.SIO_READ_PINS_REQUEST_swigconstant(_ftdi1)
SIO_READ_PINS_REQUEST = _ftdi1.SIO_READ_PINS_REQUEST

_ftdi1.SIO_READ_EEPROM_REQUEST_swigconstant(_ftdi1)
SIO_READ_EEPROM_REQUEST = _ftdi1.SIO_READ_EEPROM_REQUEST

_ftdi1.SIO_WRITE_EEPROM_REQUEST_swigconstant(_ftdi1)
SIO_WRITE_EEPROM_REQUEST = _ftdi1.SIO_WRITE_EEPROM_REQUEST

_ftdi1.SIO_ERASE_EEPROM_REQUEST_swigconstant(_ftdi1)
SIO_ERASE_EEPROM_REQUEST = _ftdi1.SIO_ERASE_EEPROM_REQUEST

_ftdi1.SIO_RESET_SIO_swigconstant(_ftdi1)
SIO_RESET_SIO = _ftdi1.SIO_RESET_SIO

_ftdi1.SIO_RESET_PURGE_RX_swigconstant(_ftdi1)
SIO_RESET_PURGE_RX = _ftdi1.SIO_RESET_PURGE_RX

_ftdi1.SIO_RESET_PURGE_TX_swigconstant(_ftdi1)
SIO_RESET_PURGE_TX = _ftdi1.SIO_RESET_PURGE_TX

_ftdi1.SIO_DISABLE_FLOW_CTRL_swigconstant(_ftdi1)
SIO_DISABLE_FLOW_CTRL = _ftdi1.SIO_DISABLE_FLOW_CTRL

_ftdi1.SIO_RTS_CTS_HS_swigconstant(_ftdi1)
SIO_RTS_CTS_HS = _ftdi1.SIO_RTS_CTS_HS

_ftdi1.SIO_DTR_DSR_HS_swigconstant(_ftdi1)
SIO_DTR_DSR_HS = _ftdi1.SIO_DTR_DSR_HS

_ftdi1.SIO_XON_XOFF_HS_swigconstant(_ftdi1)
SIO_XON_XOFF_HS = _ftdi1.SIO_XON_XOFF_HS

_ftdi1.SIO_SET_DTR_MASK_swigconstant(_ftdi1)
SIO_SET_DTR_MASK = _ftdi1.SIO_SET_DTR_MASK

_ftdi1.SIO_SET_DTR_HIGH_swigconstant(_ftdi1)
SIO_SET_DTR_HIGH = _ftdi1.SIO_SET_DTR_HIGH

_ftdi1.SIO_SET_DTR_LOW_swigconstant(_ftdi1)
SIO_SET_DTR_LOW = _ftdi1.SIO_SET_DTR_LOW

_ftdi1.SIO_SET_RTS_MASK_swigconstant(_ftdi1)
SIO_SET_RTS_MASK = _ftdi1.SIO_SET_RTS_MASK

_ftdi1.SIO_SET_RTS_HIGH_swigconstant(_ftdi1)
SIO_SET_RTS_HIGH = _ftdi1.SIO_SET_RTS_HIGH

_ftdi1.SIO_SET_RTS_LOW_swigconstant(_ftdi1)
SIO_SET_RTS_LOW = _ftdi1.SIO_SET_RTS_LOW
class transfer_control(_object):
    """Proxy of C ftdi_transfer_control struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, transfer_control, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, transfer_control, name)
    __repr__ = _swig_repr
    __swig_setmethods__["completed"] = _ftdi1.transfer_control_completed_set
    __swig_getmethods__["completed"] = _ftdi1.transfer_control_completed_get
    if _newclass:
        completed = _swig_property(_ftdi1.transfer_control_completed_get, _ftdi1.transfer_control_completed_set)
    __swig_setmethods__["buf"] = _ftdi1.transfer_control_buf_set
    __swig_getmethods__["buf"] = _ftdi1.transfer_control_buf_get
    if _newclass:
        buf = _swig_property(_ftdi1.transfer_control_buf_get, _ftdi1.transfer_control_buf_set)
    __swig_setmethods__["size"] = _ftdi1.transfer_control_size_set
    __swig_getmethods__["size"] = _ftdi1.transfer_control_size_get
    if _newclass:
        size = _swig_property(_ftdi1.transfer_control_size_get, _ftdi1.transfer_control_size_set)
    __swig_setmethods__["offset"] = _ftdi1.transfer_control_offset_set
    __swig_getmethods__["offset"] = _ftdi1.transfer_control_offset_get
    if _newclass:
        offset = _swig_property(_ftdi1.transfer_control_offset_get, _ftdi1.transfer_control_offset_set)
    __swig_setmethods__["ftdi"] = _ftdi1.transfer_control_ftdi_set
    __swig_getmethods__["ftdi"] = _ftdi1.transfer_control_ftdi_get
    if _newclass:
        ftdi = _swig_property(_ftdi1.transfer_control_ftdi_get, _ftdi1.transfer_control_ftdi_set)
    __swig_setmethods__["transfer"] = _ftdi1.transfer_control_transfer_set
    __swig_getmethods__["transfer"] = _ftdi1.transfer_control_transfer_get
    if _newclass:
        transfer = _swig_property(_ftdi1.transfer_control_transfer_get, _ftdi1.transfer_control_transfer_set)

    def __init__(self):
        """__init__(ftdi_transfer_control self) -> transfer_control"""
        this = _ftdi1.new_transfer_control()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_transfer_control
    __del__ = lambda self: None
transfer_control_swigregister = _ftdi1.transfer_control_swigregister
transfer_control_swigregister(transfer_control)

class context(_object):
    """Proxy of C ftdi_context struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, context, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, context, name)
    __repr__ = _swig_repr
    __swig_setmethods__["usb_ctx"] = _ftdi1.context_usb_ctx_set
    __swig_getmethods__["usb_ctx"] = _ftdi1.context_usb_ctx_get
    if _newclass:
        usb_ctx = _swig_property(_ftdi1.context_usb_ctx_get, _ftdi1.context_usb_ctx_set)
    __swig_setmethods__["usb_dev"] = _ftdi1.context_usb_dev_set
    __swig_getmethods__["usb_dev"] = _ftdi1.context_usb_dev_get
    if _newclass:
        usb_dev = _swig_property(_ftdi1.context_usb_dev_get, _ftdi1.context_usb_dev_set)
    __swig_setmethods__["usb_read_timeout"] = _ftdi1.context_usb_read_timeout_set
    __swig_getmethods__["usb_read_timeout"] = _ftdi1.context_usb_read_timeout_get
    if _newclass:
        usb_read_timeout = _swig_property(_ftdi1.context_usb_read_timeout_get, _ftdi1.context_usb_read_timeout_set)
    __swig_setmethods__["usb_write_timeout"] = _ftdi1.context_usb_write_timeout_set
    __swig_getmethods__["usb_write_timeout"] = _ftdi1.context_usb_write_timeout_get
    if _newclass:
        usb_write_timeout = _swig_property(_ftdi1.context_usb_write_timeout_get, _ftdi1.context_usb_write_timeout_set)
    __swig_setmethods__["type"] = _ftdi1.context_type_set
    __swig_getmethods__["type"] = _ftdi1.context_type_get
    if _newclass:
        type = _swig_property(_ftdi1.context_type_get, _ftdi1.context_type_set)
    __swig_setmethods__["baudrate"] = _ftdi1.context_baudrate_set
    __swig_getmethods__["baudrate"] = _ftdi1.context_baudrate_get
    if _newclass:
        baudrate = _swig_property(_ftdi1.context_baudrate_get, _ftdi1.context_baudrate_set)
    __swig_setmethods__["bitbang_enabled"] = _ftdi1.context_bitbang_enabled_set
    __swig_getmethods__["bitbang_enabled"] = _ftdi1.context_bitbang_enabled_get
    if _newclass:
        bitbang_enabled = _swig_property(_ftdi1.context_bitbang_enabled_get, _ftdi1.context_bitbang_enabled_set)
    __swig_setmethods__["readbuffer"] = _ftdi1.context_readbuffer_set
    __swig_getmethods__["readbuffer"] = _ftdi1.context_readbuffer_get
    if _newclass:
        readbuffer = _swig_property(_ftdi1.context_readbuffer_get, _ftdi1.context_readbuffer_set)
    __swig_setmethods__["readbuffer_offset"] = _ftdi1.context_readbuffer_offset_set
    __swig_getmethods__["readbuffer_offset"] = _ftdi1.context_readbuffer_offset_get
    if _newclass:
        readbuffer_offset = _swig_property(_ftdi1.context_readbuffer_offset_get, _ftdi1.context_readbuffer_offset_set)
    __swig_setmethods__["readbuffer_remaining"] = _ftdi1.context_readbuffer_remaining_set
    __swig_getmethods__["readbuffer_remaining"] = _ftdi1.context_readbuffer_remaining_get
    if _newclass:
        readbuffer_remaining = _swig_property(_ftdi1.context_readbuffer_remaining_get, _ftdi1.context_readbuffer_remaining_set)
    __swig_setmethods__["readbuffer_chunksize"] = _ftdi1.context_readbuffer_chunksize_set
    __swig_getmethods__["readbuffer_chunksize"] = _ftdi1.context_readbuffer_chunksize_get
    if _newclass:
        readbuffer_chunksize = _swig_property(_ftdi1.context_readbuffer_chunksize_get, _ftdi1.context_readbuffer_chunksize_set)
    __swig_setmethods__["writebuffer_chunksize"] = _ftdi1.context_writebuffer_chunksize_set
    __swig_getmethods__["writebuffer_chunksize"] = _ftdi1.context_writebuffer_chunksize_get
    if _newclass:
        writebuffer_chunksize = _swig_property(_ftdi1.context_writebuffer_chunksize_get, _ftdi1.context_writebuffer_chunksize_set)
    __swig_setmethods__["max_packet_size"] = _ftdi1.context_max_packet_size_set
    __swig_getmethods__["max_packet_size"] = _ftdi1.context_max_packet_size_get
    if _newclass:
        max_packet_size = _swig_property(_ftdi1.context_max_packet_size_get, _ftdi1.context_max_packet_size_set)
    __swig_setmethods__["interface"] = _ftdi1.context_interface_set
    __swig_getmethods__["interface"] = _ftdi1.context_interface_get
    if _newclass:
        interface = _swig_property(_ftdi1.context_interface_get, _ftdi1.context_interface_set)
    __swig_setmethods__["index"] = _ftdi1.context_index_set
    __swig_getmethods__["index"] = _ftdi1.context_index_get
    if _newclass:
        index = _swig_property(_ftdi1.context_index_get, _ftdi1.context_index_set)
    __swig_setmethods__["in_ep"] = _ftdi1.context_in_ep_set
    __swig_getmethods__["in_ep"] = _ftdi1.context_in_ep_get
    if _newclass:
        in_ep = _swig_property(_ftdi1.context_in_ep_get, _ftdi1.context_in_ep_set)
    __swig_setmethods__["out_ep"] = _ftdi1.context_out_ep_set
    __swig_getmethods__["out_ep"] = _ftdi1.context_out_ep_get
    if _newclass:
        out_ep = _swig_property(_ftdi1.context_out_ep_get, _ftdi1.context_out_ep_set)
    __swig_setmethods__["bitbang_mode"] = _ftdi1.context_bitbang_mode_set
    __swig_getmethods__["bitbang_mode"] = _ftdi1.context_bitbang_mode_get
    if _newclass:
        bitbang_mode = _swig_property(_ftdi1.context_bitbang_mode_get, _ftdi1.context_bitbang_mode_set)
    __swig_setmethods__["eeprom"] = _ftdi1.context_eeprom_set
    __swig_getmethods__["eeprom"] = _ftdi1.context_eeprom_get
    if _newclass:
        eeprom = _swig_property(_ftdi1.context_eeprom_get, _ftdi1.context_eeprom_set)
    __swig_setmethods__["error_str"] = _ftdi1.context_error_str_set
    __swig_getmethods__["error_str"] = _ftdi1.context_error_str_get
    if _newclass:
        error_str = _swig_property(_ftdi1.context_error_str_get, _ftdi1.context_error_str_set)
    __swig_setmethods__["module_detach_mode"] = _ftdi1.context_module_detach_mode_set
    __swig_getmethods__["module_detach_mode"] = _ftdi1.context_module_detach_mode_get
    if _newclass:
        module_detach_mode = _swig_property(_ftdi1.context_module_detach_mode_get, _ftdi1.context_module_detach_mode_set)

    def __init__(self):
        """__init__(ftdi_context self) -> context"""
        this = _ftdi1.new_context()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_context
    __del__ = lambda self: None
context_swigregister = _ftdi1.context_swigregister
context_swigregister(context)


_ftdi1.VENDOR_ID_swigconstant(_ftdi1)
VENDOR_ID = _ftdi1.VENDOR_ID

_ftdi1.PRODUCT_ID_swigconstant(_ftdi1)
PRODUCT_ID = _ftdi1.PRODUCT_ID

_ftdi1.SELF_POWERED_swigconstant(_ftdi1)
SELF_POWERED = _ftdi1.SELF_POWERED

_ftdi1.REMOTE_WAKEUP_swigconstant(_ftdi1)
REMOTE_WAKEUP = _ftdi1.REMOTE_WAKEUP

_ftdi1.IS_NOT_PNP_swigconstant(_ftdi1)
IS_NOT_PNP = _ftdi1.IS_NOT_PNP

_ftdi1.SUSPEND_DBUS7_swigconstant(_ftdi1)
SUSPEND_DBUS7 = _ftdi1.SUSPEND_DBUS7

_ftdi1.IN_IS_ISOCHRONOUS_swigconstant(_ftdi1)
IN_IS_ISOCHRONOUS = _ftdi1.IN_IS_ISOCHRONOUS

_ftdi1.OUT_IS_ISOCHRONOUS_swigconstant(_ftdi1)
OUT_IS_ISOCHRONOUS = _ftdi1.OUT_IS_ISOCHRONOUS

_ftdi1.SUSPEND_PULL_DOWNS_swigconstant(_ftdi1)
SUSPEND_PULL_DOWNS = _ftdi1.SUSPEND_PULL_DOWNS

_ftdi1.USE_SERIAL_swigconstant(_ftdi1)
USE_SERIAL = _ftdi1.USE_SERIAL

_ftdi1.USB_VERSION_swigconstant(_ftdi1)
USB_VERSION = _ftdi1.USB_VERSION

_ftdi1.USE_USB_VERSION_swigconstant(_ftdi1)
USE_USB_VERSION = _ftdi1.USE_USB_VERSION

_ftdi1.MAX_POWER_swigconstant(_ftdi1)
MAX_POWER = _ftdi1.MAX_POWER

_ftdi1.CHANNEL_A_TYPE_swigconstant(_ftdi1)
CHANNEL_A_TYPE = _ftdi1.CHANNEL_A_TYPE

_ftdi1.CHANNEL_B_TYPE_swigconstant(_ftdi1)
CHANNEL_B_TYPE = _ftdi1.CHANNEL_B_TYPE

_ftdi1.CHANNEL_A_DRIVER_swigconstant(_ftdi1)
CHANNEL_A_DRIVER = _ftdi1.CHANNEL_A_DRIVER

_ftdi1.CHANNEL_B_DRIVER_swigconstant(_ftdi1)
CHANNEL_B_DRIVER = _ftdi1.CHANNEL_B_DRIVER

_ftdi1.CBUS_FUNCTION_0_swigconstant(_ftdi1)
CBUS_FUNCTION_0 = _ftdi1.CBUS_FUNCTION_0

_ftdi1.CBUS_FUNCTION_1_swigconstant(_ftdi1)
CBUS_FUNCTION_1 = _ftdi1.CBUS_FUNCTION_1

_ftdi1.CBUS_FUNCTION_2_swigconstant(_ftdi1)
CBUS_FUNCTION_2 = _ftdi1.CBUS_FUNCTION_2

_ftdi1.CBUS_FUNCTION_3_swigconstant(_ftdi1)
CBUS_FUNCTION_3 = _ftdi1.CBUS_FUNCTION_3

_ftdi1.CBUS_FUNCTION_4_swigconstant(_ftdi1)
CBUS_FUNCTION_4 = _ftdi1.CBUS_FUNCTION_4

_ftdi1.CBUS_FUNCTION_5_swigconstant(_ftdi1)
CBUS_FUNCTION_5 = _ftdi1.CBUS_FUNCTION_5

_ftdi1.CBUS_FUNCTION_6_swigconstant(_ftdi1)
CBUS_FUNCTION_6 = _ftdi1.CBUS_FUNCTION_6

_ftdi1.CBUS_FUNCTION_7_swigconstant(_ftdi1)
CBUS_FUNCTION_7 = _ftdi1.CBUS_FUNCTION_7

_ftdi1.CBUS_FUNCTION_8_swigconstant(_ftdi1)
CBUS_FUNCTION_8 = _ftdi1.CBUS_FUNCTION_8

_ftdi1.CBUS_FUNCTION_9_swigconstant(_ftdi1)
CBUS_FUNCTION_9 = _ftdi1.CBUS_FUNCTION_9

_ftdi1.HIGH_CURRENT_swigconstant(_ftdi1)
HIGH_CURRENT = _ftdi1.HIGH_CURRENT

_ftdi1.HIGH_CURRENT_A_swigconstant(_ftdi1)
HIGH_CURRENT_A = _ftdi1.HIGH_CURRENT_A

_ftdi1.HIGH_CURRENT_B_swigconstant(_ftdi1)
HIGH_CURRENT_B = _ftdi1.HIGH_CURRENT_B

_ftdi1.INVERT_swigconstant(_ftdi1)
INVERT = _ftdi1.INVERT

_ftdi1.GROUP0_DRIVE_swigconstant(_ftdi1)
GROUP0_DRIVE = _ftdi1.GROUP0_DRIVE

_ftdi1.GROUP0_SCHMITT_swigconstant(_ftdi1)
GROUP0_SCHMITT = _ftdi1.GROUP0_SCHMITT

_ftdi1.GROUP0_SLEW_swigconstant(_ftdi1)
GROUP0_SLEW = _ftdi1.GROUP0_SLEW

_ftdi1.GROUP1_DRIVE_swigconstant(_ftdi1)
GROUP1_DRIVE = _ftdi1.GROUP1_DRIVE

_ftdi1.GROUP1_SCHMITT_swigconstant(_ftdi1)
GROUP1_SCHMITT = _ftdi1.GROUP1_SCHMITT

_ftdi1.GROUP1_SLEW_swigconstant(_ftdi1)
GROUP1_SLEW = _ftdi1.GROUP1_SLEW

_ftdi1.GROUP2_DRIVE_swigconstant(_ftdi1)
GROUP2_DRIVE = _ftdi1.GROUP2_DRIVE

_ftdi1.GROUP2_SCHMITT_swigconstant(_ftdi1)
GROUP2_SCHMITT = _ftdi1.GROUP2_SCHMITT

_ftdi1.GROUP2_SLEW_swigconstant(_ftdi1)
GROUP2_SLEW = _ftdi1.GROUP2_SLEW

_ftdi1.GROUP3_DRIVE_swigconstant(_ftdi1)
GROUP3_DRIVE = _ftdi1.GROUP3_DRIVE

_ftdi1.GROUP3_SCHMITT_swigconstant(_ftdi1)
GROUP3_SCHMITT = _ftdi1.GROUP3_SCHMITT

_ftdi1.GROUP3_SLEW_swigconstant(_ftdi1)
GROUP3_SLEW = _ftdi1.GROUP3_SLEW

_ftdi1.CHIP_SIZE_swigconstant(_ftdi1)
CHIP_SIZE = _ftdi1.CHIP_SIZE

_ftdi1.CHIP_TYPE_swigconstant(_ftdi1)
CHIP_TYPE = _ftdi1.CHIP_TYPE

_ftdi1.POWER_SAVE_swigconstant(_ftdi1)
POWER_SAVE = _ftdi1.POWER_SAVE

_ftdi1.CLOCK_POLARITY_swigconstant(_ftdi1)
CLOCK_POLARITY = _ftdi1.CLOCK_POLARITY

_ftdi1.DATA_ORDER_swigconstant(_ftdi1)
DATA_ORDER = _ftdi1.DATA_ORDER

_ftdi1.FLOW_CONTROL_swigconstant(_ftdi1)
FLOW_CONTROL = _ftdi1.FLOW_CONTROL

_ftdi1.CHANNEL_C_DRIVER_swigconstant(_ftdi1)
CHANNEL_C_DRIVER = _ftdi1.CHANNEL_C_DRIVER

_ftdi1.CHANNEL_D_DRIVER_swigconstant(_ftdi1)
CHANNEL_D_DRIVER = _ftdi1.CHANNEL_D_DRIVER

_ftdi1.CHANNEL_A_RS485_swigconstant(_ftdi1)
CHANNEL_A_RS485 = _ftdi1.CHANNEL_A_RS485

_ftdi1.CHANNEL_B_RS485_swigconstant(_ftdi1)
CHANNEL_B_RS485 = _ftdi1.CHANNEL_B_RS485

_ftdi1.CHANNEL_C_RS485_swigconstant(_ftdi1)
CHANNEL_C_RS485 = _ftdi1.CHANNEL_C_RS485

_ftdi1.CHANNEL_D_RS485_swigconstant(_ftdi1)
CHANNEL_D_RS485 = _ftdi1.CHANNEL_D_RS485

_ftdi1.RELEASE_NUMBER_swigconstant(_ftdi1)
RELEASE_NUMBER = _ftdi1.RELEASE_NUMBER
class device_list(_object):
    """Proxy of C ftdi_device_list struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, device_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, device_list, name)
    __repr__ = _swig_repr
    __swig_setmethods__["next"] = _ftdi1.device_list_next_set
    __swig_getmethods__["next"] = _ftdi1.device_list_next_get
    if _newclass:
        next = _swig_property(_ftdi1.device_list_next_get, _ftdi1.device_list_next_set)
    __swig_setmethods__["dev"] = _ftdi1.device_list_dev_set
    __swig_getmethods__["dev"] = _ftdi1.device_list_dev_get
    if _newclass:
        dev = _swig_property(_ftdi1.device_list_dev_get, _ftdi1.device_list_dev_set)

    def __init__(self):
        """__init__(ftdi_device_list self) -> device_list"""
        this = _ftdi1.new_device_list()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_device_list
    __del__ = lambda self: None
device_list_swigregister = _ftdi1.device_list_swigregister
device_list_swigregister(device_list)


_ftdi1.FT1284_CLK_IDLE_STATE_swigconstant(_ftdi1)
FT1284_CLK_IDLE_STATE = _ftdi1.FT1284_CLK_IDLE_STATE

_ftdi1.FT1284_DATA_LSB_swigconstant(_ftdi1)
FT1284_DATA_LSB = _ftdi1.FT1284_DATA_LSB

_ftdi1.FT1284_FLOW_CONTROL_swigconstant(_ftdi1)
FT1284_FLOW_CONTROL = _ftdi1.FT1284_FLOW_CONTROL

_ftdi1.POWER_SAVE_DISABLE_H_swigconstant(_ftdi1)
POWER_SAVE_DISABLE_H = _ftdi1.POWER_SAVE_DISABLE_H

_ftdi1.USE_SERIAL_NUM_swigconstant(_ftdi1)
USE_SERIAL_NUM = _ftdi1.USE_SERIAL_NUM

_ftdi1.CBUS_TXDEN_swigconstant(_ftdi1)
CBUS_TXDEN = _ftdi1.CBUS_TXDEN

_ftdi1.CBUS_PWREN_swigconstant(_ftdi1)
CBUS_PWREN = _ftdi1.CBUS_PWREN

_ftdi1.CBUS_RXLED_swigconstant(_ftdi1)
CBUS_RXLED = _ftdi1.CBUS_RXLED

_ftdi1.CBUS_TXLED_swigconstant(_ftdi1)
CBUS_TXLED = _ftdi1.CBUS_TXLED

_ftdi1.CBUS_TXRXLED_swigconstant(_ftdi1)
CBUS_TXRXLED = _ftdi1.CBUS_TXRXLED

_ftdi1.CBUS_SLEEP_swigconstant(_ftdi1)
CBUS_SLEEP = _ftdi1.CBUS_SLEEP

_ftdi1.CBUS_CLK48_swigconstant(_ftdi1)
CBUS_CLK48 = _ftdi1.CBUS_CLK48

_ftdi1.CBUS_CLK24_swigconstant(_ftdi1)
CBUS_CLK24 = _ftdi1.CBUS_CLK24

_ftdi1.CBUS_CLK12_swigconstant(_ftdi1)
CBUS_CLK12 = _ftdi1.CBUS_CLK12

_ftdi1.CBUS_CLK6_swigconstant(_ftdi1)
CBUS_CLK6 = _ftdi1.CBUS_CLK6

_ftdi1.CBUS_IOMODE_swigconstant(_ftdi1)
CBUS_IOMODE = _ftdi1.CBUS_IOMODE

_ftdi1.CBUS_BB_WR_swigconstant(_ftdi1)
CBUS_BB_WR = _ftdi1.CBUS_BB_WR

_ftdi1.CBUS_BB_RD_swigconstant(_ftdi1)
CBUS_BB_RD = _ftdi1.CBUS_BB_RD

_ftdi1.CBUS_BB_swigconstant(_ftdi1)
CBUS_BB = _ftdi1.CBUS_BB

_ftdi1.CBUSH_TRISTATE_swigconstant(_ftdi1)
CBUSH_TRISTATE = _ftdi1.CBUSH_TRISTATE

_ftdi1.CBUSH_RXLED_swigconstant(_ftdi1)
CBUSH_RXLED = _ftdi1.CBUSH_RXLED

_ftdi1.CBUSH_TXLED_swigconstant(_ftdi1)
CBUSH_TXLED = _ftdi1.CBUSH_TXLED

_ftdi1.CBUSH_TXRXLED_swigconstant(_ftdi1)
CBUSH_TXRXLED = _ftdi1.CBUSH_TXRXLED

_ftdi1.CBUSH_PWREN_swigconstant(_ftdi1)
CBUSH_PWREN = _ftdi1.CBUSH_PWREN

_ftdi1.CBUSH_SLEEP_swigconstant(_ftdi1)
CBUSH_SLEEP = _ftdi1.CBUSH_SLEEP

_ftdi1.CBUSH_DRIVE_0_swigconstant(_ftdi1)
CBUSH_DRIVE_0 = _ftdi1.CBUSH_DRIVE_0

_ftdi1.CBUSG_DRIVE1_swigconstant(_ftdi1)
CBUSG_DRIVE1 = _ftdi1.CBUSG_DRIVE1

_ftdi1.CBUSH_IOMODE_swigconstant(_ftdi1)
CBUSH_IOMODE = _ftdi1.CBUSH_IOMODE

_ftdi1.CBUSH_TXDEN_swigconstant(_ftdi1)
CBUSH_TXDEN = _ftdi1.CBUSH_TXDEN

_ftdi1.CBUSH_CLK30_swigconstant(_ftdi1)
CBUSH_CLK30 = _ftdi1.CBUSH_CLK30

_ftdi1.CBUSH_CLK15_swigconstant(_ftdi1)
CBUSH_CLK15 = _ftdi1.CBUSH_CLK15

_ftdi1.CBUSH_CLK7_5_swigconstant(_ftdi1)
CBUSH_CLK7_5 = _ftdi1.CBUSH_CLK7_5

_ftdi1.CBUSH_BAT_DETECT_swigconstant(_ftdi1)
CBUSH_BAT_DETECT = _ftdi1.CBUSH_BAT_DETECT

_ftdi1.CBUSH_BAT_DETECT_NEG_swigconstant(_ftdi1)
CBUSH_BAT_DETECT_NEG = _ftdi1.CBUSH_BAT_DETECT_NEG

_ftdi1.CBUSH_I2C_TXE_swigconstant(_ftdi1)
CBUSH_I2C_TXE = _ftdi1.CBUSH_I2C_TXE

_ftdi1.CBUSH_I2C_RXF_swigconstant(_ftdi1)
CBUSH_I2C_RXF = _ftdi1.CBUSH_I2C_RXF

_ftdi1.CBUSH_VBUS_SENSE_swigconstant(_ftdi1)
CBUSH_VBUS_SENSE = _ftdi1.CBUSH_VBUS_SENSE

_ftdi1.CBUSH_BB_WR_swigconstant(_ftdi1)
CBUSH_BB_WR = _ftdi1.CBUSH_BB_WR

_ftdi1.CBUSH_BB_RD_swigconstant(_ftdi1)
CBUSH_BB_RD = _ftdi1.CBUSH_BB_RD

_ftdi1.CBUSH_TIME_STAMP_swigconstant(_ftdi1)
CBUSH_TIME_STAMP = _ftdi1.CBUSH_TIME_STAMP

_ftdi1.CBUSH_AWAKE_swigconstant(_ftdi1)
CBUSH_AWAKE = _ftdi1.CBUSH_AWAKE

_ftdi1.INVERT_TXD_swigconstant(_ftdi1)
INVERT_TXD = _ftdi1.INVERT_TXD

_ftdi1.INVERT_RXD_swigconstant(_ftdi1)
INVERT_RXD = _ftdi1.INVERT_RXD

_ftdi1.INVERT_RTS_swigconstant(_ftdi1)
INVERT_RTS = _ftdi1.INVERT_RTS

_ftdi1.INVERT_CTS_swigconstant(_ftdi1)
INVERT_CTS = _ftdi1.INVERT_CTS

_ftdi1.INVERT_DTR_swigconstant(_ftdi1)
INVERT_DTR = _ftdi1.INVERT_DTR

_ftdi1.INVERT_DSR_swigconstant(_ftdi1)
INVERT_DSR = _ftdi1.INVERT_DSR

_ftdi1.INVERT_DCD_swigconstant(_ftdi1)
INVERT_DCD = _ftdi1.INVERT_DCD

_ftdi1.INVERT_RI_swigconstant(_ftdi1)
INVERT_RI = _ftdi1.INVERT_RI

_ftdi1.CHANNEL_IS_UART_swigconstant(_ftdi1)
CHANNEL_IS_UART = _ftdi1.CHANNEL_IS_UART

_ftdi1.CHANNEL_IS_FIFO_swigconstant(_ftdi1)
CHANNEL_IS_FIFO = _ftdi1.CHANNEL_IS_FIFO

_ftdi1.CHANNEL_IS_OPTO_swigconstant(_ftdi1)
CHANNEL_IS_OPTO = _ftdi1.CHANNEL_IS_OPTO

_ftdi1.CHANNEL_IS_CPU_swigconstant(_ftdi1)
CHANNEL_IS_CPU = _ftdi1.CHANNEL_IS_CPU

_ftdi1.CHANNEL_IS_FT1284_swigconstant(_ftdi1)
CHANNEL_IS_FT1284 = _ftdi1.CHANNEL_IS_FT1284

_ftdi1.CHANNEL_IS_RS485_swigconstant(_ftdi1)
CHANNEL_IS_RS485 = _ftdi1.CHANNEL_IS_RS485

_ftdi1.DRIVE_4MA_swigconstant(_ftdi1)
DRIVE_4MA = _ftdi1.DRIVE_4MA

_ftdi1.DRIVE_8MA_swigconstant(_ftdi1)
DRIVE_8MA = _ftdi1.DRIVE_8MA

_ftdi1.DRIVE_12MA_swigconstant(_ftdi1)
DRIVE_12MA = _ftdi1.DRIVE_12MA

_ftdi1.DRIVE_16MA_swigconstant(_ftdi1)
DRIVE_16MA = _ftdi1.DRIVE_16MA

_ftdi1.SLOW_SLEW_swigconstant(_ftdi1)
SLOW_SLEW = _ftdi1.SLOW_SLEW

_ftdi1.IS_SCHMITT_swigconstant(_ftdi1)
IS_SCHMITT = _ftdi1.IS_SCHMITT

_ftdi1.DRIVER_VCP_swigconstant(_ftdi1)
DRIVER_VCP = _ftdi1.DRIVER_VCP

_ftdi1.DRIVER_VCPH_swigconstant(_ftdi1)
DRIVER_VCPH = _ftdi1.DRIVER_VCPH

_ftdi1.USE_USB_VERSION_BIT_swigconstant(_ftdi1)
USE_USB_VERSION_BIT = _ftdi1.USE_USB_VERSION_BIT

_ftdi1.SUSPEND_DBUS7_BIT_swigconstant(_ftdi1)
SUSPEND_DBUS7_BIT = _ftdi1.SUSPEND_DBUS7_BIT

_ftdi1.HIGH_CURRENT_DRIVE_swigconstant(_ftdi1)
HIGH_CURRENT_DRIVE = _ftdi1.HIGH_CURRENT_DRIVE

_ftdi1.HIGH_CURRENT_DRIVE_R_swigconstant(_ftdi1)
HIGH_CURRENT_DRIVE_R = _ftdi1.HIGH_CURRENT_DRIVE_R
class size_and_time(_object):
    """Proxy of C size_and_time struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, size_and_time, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, size_and_time, name)
    __repr__ = _swig_repr
    __swig_setmethods__["totalBytes"] = _ftdi1.size_and_time_totalBytes_set
    __swig_getmethods__["totalBytes"] = _ftdi1.size_and_time_totalBytes_get
    if _newclass:
        totalBytes = _swig_property(_ftdi1.size_and_time_totalBytes_get, _ftdi1.size_and_time_totalBytes_set)
    __swig_setmethods__["time"] = _ftdi1.size_and_time_time_set
    __swig_getmethods__["time"] = _ftdi1.size_and_time_time_get
    if _newclass:
        time = _swig_property(_ftdi1.size_and_time_time_get, _ftdi1.size_and_time_time_set)

    def __init__(self):
        """__init__(size_and_time self) -> size_and_time"""
        this = _ftdi1.new_size_and_time()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_size_and_time
    __del__ = lambda self: None
size_and_time_swigregister = _ftdi1.size_and_time_swigregister
size_and_time_swigregister(size_and_time)

class FTDIProgressInfo(_object):
    """Proxy of C FTDIProgressInfo struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FTDIProgressInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FTDIProgressInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["first"] = _ftdi1.FTDIProgressInfo_first_set
    __swig_getmethods__["first"] = _ftdi1.FTDIProgressInfo_first_get
    if _newclass:
        first = _swig_property(_ftdi1.FTDIProgressInfo_first_get, _ftdi1.FTDIProgressInfo_first_set)
    __swig_setmethods__["prev"] = _ftdi1.FTDIProgressInfo_prev_set
    __swig_getmethods__["prev"] = _ftdi1.FTDIProgressInfo_prev_get
    if _newclass:
        prev = _swig_property(_ftdi1.FTDIProgressInfo_prev_get, _ftdi1.FTDIProgressInfo_prev_set)
    __swig_setmethods__["current"] = _ftdi1.FTDIProgressInfo_current_set
    __swig_getmethods__["current"] = _ftdi1.FTDIProgressInfo_current_get
    if _newclass:
        current = _swig_property(_ftdi1.FTDIProgressInfo_current_get, _ftdi1.FTDIProgressInfo_current_set)
    __swig_setmethods__["totalTime"] = _ftdi1.FTDIProgressInfo_totalTime_set
    __swig_getmethods__["totalTime"] = _ftdi1.FTDIProgressInfo_totalTime_get
    if _newclass:
        totalTime = _swig_property(_ftdi1.FTDIProgressInfo_totalTime_get, _ftdi1.FTDIProgressInfo_totalTime_set)
    __swig_setmethods__["totalRate"] = _ftdi1.FTDIProgressInfo_totalRate_set
    __swig_getmethods__["totalRate"] = _ftdi1.FTDIProgressInfo_totalRate_get
    if _newclass:
        totalRate = _swig_property(_ftdi1.FTDIProgressInfo_totalRate_get, _ftdi1.FTDIProgressInfo_totalRate_set)
    __swig_setmethods__["currentRate"] = _ftdi1.FTDIProgressInfo_currentRate_set
    __swig_getmethods__["currentRate"] = _ftdi1.FTDIProgressInfo_currentRate_get
    if _newclass:
        currentRate = _swig_property(_ftdi1.FTDIProgressInfo_currentRate_get, _ftdi1.FTDIProgressInfo_currentRate_set)

    def __init__(self):
        """__init__(FTDIProgressInfo self) -> FTDIProgressInfo"""
        this = _ftdi1.new_FTDIProgressInfo()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_FTDIProgressInfo
    __del__ = lambda self: None
FTDIProgressInfo_swigregister = _ftdi1.FTDIProgressInfo_swigregister
FTDIProgressInfo_swigregister(FTDIProgressInfo)

class version_info(_object):
    """Proxy of C ftdi_version_info struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, version_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, version_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["major"] = _ftdi1.version_info_major_set
    __swig_getmethods__["major"] = _ftdi1.version_info_major_get
    if _newclass:
        major = _swig_property(_ftdi1.version_info_major_get, _ftdi1.version_info_major_set)
    __swig_setmethods__["minor"] = _ftdi1.version_info_minor_set
    __swig_getmethods__["minor"] = _ftdi1.version_info_minor_get
    if _newclass:
        minor = _swig_property(_ftdi1.version_info_minor_get, _ftdi1.version_info_minor_set)
    __swig_setmethods__["micro"] = _ftdi1.version_info_micro_set
    __swig_getmethods__["micro"] = _ftdi1.version_info_micro_get
    if _newclass:
        micro = _swig_property(_ftdi1.version_info_micro_get, _ftdi1.version_info_micro_set)
    __swig_getmethods__["version_str"] = _ftdi1.version_info_version_str_get
    if _newclass:
        version_str = _swig_property(_ftdi1.version_info_version_str_get)
    __swig_getmethods__["snapshot_str"] = _ftdi1.version_info_snapshot_str_get
    if _newclass:
        snapshot_str = _swig_property(_ftdi1.version_info_snapshot_str_get)

    def __init__(self):
        """__init__(ftdi_version_info self) -> version_info"""
        this = _ftdi1.new_version_info()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_version_info
    __del__ = lambda self: None
version_info_swigregister = _ftdi1.version_info_swigregister
version_info_swigregister(version_info)


def init(ftdi):
    """init(context ftdi) -> int"""
    return _ftdi1.init(ftdi)

def new():
    """new() -> context"""
    return _ftdi1.new()

def set_interface(ftdi, interface):
    """set_interface(context ftdi, enum ftdi_interface interface) -> int"""
    return _ftdi1.set_interface(ftdi, interface)

def deinit(ftdi):
    """deinit(context ftdi)"""
    return _ftdi1.deinit(ftdi)

def free(ftdi):
    """free(context ftdi)"""
    return _ftdi1.free(ftdi)

def set_usbdev(ftdi, usbdev):
    """set_usbdev(context ftdi, struct libusb_device_handle * usbdev)"""
    return _ftdi1.set_usbdev(ftdi, usbdev)

def get_library_version():
    """get_library_version() -> version_info"""
    return _ftdi1.get_library_version()

def list_free(devlist):
    """list_free(struct ftdi_device_list ** devlist)"""
    return _ftdi1.list_free(devlist)

def list_free2(devlist):
    """list_free2(device_list devlist)"""
    return _ftdi1.list_free2(devlist)

def eeprom_set_strings(ftdi, manufacturer, product, serial):
    """eeprom_set_strings(context ftdi, char * manufacturer, char * product, char * serial) -> int"""
    return _ftdi1.eeprom_set_strings(ftdi, manufacturer, product, serial)

def usb_open(ftdi, vendor, product):
    """usb_open(context ftdi, int vendor, int product) -> int"""
    return _ftdi1.usb_open(ftdi, vendor, product)

def usb_open_desc(ftdi, vendor, product, description, serial):
    """usb_open_desc(context ftdi, int vendor, int product, char const * description, char const * serial) -> int"""
    return _ftdi1.usb_open_desc(ftdi, vendor, product, description, serial)

def usb_open_desc_index(ftdi, vendor, product, description, serial, index):
    """usb_open_desc_index(context ftdi, int vendor, int product, char const * description, char const * serial, unsigned int index) -> int"""
    return _ftdi1.usb_open_desc_index(ftdi, vendor, product, description, serial, index)

def usb_open_dev(ftdi, dev):
    """usb_open_dev(context ftdi, struct libusb_device * dev) -> int"""
    return _ftdi1.usb_open_dev(ftdi, dev)

def usb_open_string(ftdi, description):
    """usb_open_string(context ftdi, char const * description) -> int"""
    return _ftdi1.usb_open_string(ftdi, description)

def usb_close(ftdi):
    """usb_close(context ftdi) -> int"""
    return _ftdi1.usb_close(ftdi)

def usb_reset(ftdi):
    """usb_reset(context ftdi) -> int"""
    return _ftdi1.usb_reset(ftdi)

def usb_purge_rx_buffer(ftdi):
    """usb_purge_rx_buffer(context ftdi) -> int"""
    return _ftdi1.usb_purge_rx_buffer(ftdi)

def usb_purge_tx_buffer(ftdi):
    """usb_purge_tx_buffer(context ftdi) -> int"""
    return _ftdi1.usb_purge_tx_buffer(ftdi)

def usb_purge_buffers(ftdi):
    """usb_purge_buffers(context ftdi) -> int"""
    return _ftdi1.usb_purge_buffers(ftdi)

def set_baudrate(ftdi, baudrate):
    """set_baudrate(context ftdi, int baudrate) -> int"""
    return _ftdi1.set_baudrate(ftdi, baudrate)

def set_line_property(ftdi, bits, sbit, parity):
    """set_line_property(context ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity) -> int"""
    return _ftdi1.set_line_property(ftdi, bits, sbit, parity)

def set_line_property2(ftdi, bits, sbit, parity, break_type):
    """set_line_property2(context ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type) -> int"""
    return _ftdi1.set_line_property2(ftdi, bits, sbit, parity, break_type)

def read_data_set_chunksize(ftdi, chunksize):
    """read_data_set_chunksize(context ftdi, unsigned int chunksize) -> int"""
    return _ftdi1.read_data_set_chunksize(ftdi, chunksize)

def write_data(ftdi, buf, size):
    """write_data(context ftdi, unsigned char const * buf, int size) -> int"""
    return _ftdi1.write_data(ftdi, buf, size)

def write_data_set_chunksize(ftdi, chunksize):
    """write_data_set_chunksize(context ftdi, unsigned int chunksize) -> int"""
    return _ftdi1.write_data_set_chunksize(ftdi, chunksize)

def readstream(ftdi, callback, userdata, packetsPerTransfer, numTransfers):
    """readstream(context ftdi, FTDIStreamCallback * callback, void * userdata, int packetsPerTransfer, int numTransfers) -> int"""
    return _ftdi1.readstream(ftdi, callback, userdata, packetsPerTransfer, numTransfers)

def write_data_submit(ftdi, buf, size):
    """write_data_submit(context ftdi, unsigned char * buf, int size) -> transfer_control"""
    return _ftdi1.write_data_submit(ftdi, buf, size)

def read_data_submit(ftdi, buf, size):
    """read_data_submit(context ftdi, unsigned char * buf, int size) -> transfer_control"""
    return _ftdi1.read_data_submit(ftdi, buf, size)

def transfer_data_done(tc):
    """transfer_data_done(transfer_control tc) -> int"""
    return _ftdi1.transfer_data_done(tc)

def set_bitmode(ftdi, bitmask, mode):
    """set_bitmode(context ftdi, unsigned char bitmask, unsigned char mode) -> int"""
    return _ftdi1.set_bitmode(ftdi, bitmask, mode)

def disable_bitbang(ftdi):
    """disable_bitbang(context ftdi) -> int"""
    return _ftdi1.disable_bitbang(ftdi)

def set_latency_timer(ftdi, latency):
    """set_latency_timer(context ftdi, unsigned char latency) -> int"""
    return _ftdi1.set_latency_timer(ftdi, latency)

def setflowctrl(ftdi, flowctrl):
    """setflowctrl(context ftdi, int flowctrl) -> int"""
    return _ftdi1.setflowctrl(ftdi, flowctrl)

def setdtr_rts(ftdi, dtr, rts):
    """setdtr_rts(context ftdi, int dtr, int rts) -> int"""
    return _ftdi1.setdtr_rts(ftdi, dtr, rts)

def setdtr(ftdi, state):
    """setdtr(context ftdi, int state) -> int"""
    return _ftdi1.setdtr(ftdi, state)

def setrts(ftdi, state):
    """setrts(context ftdi, int state) -> int"""
    return _ftdi1.setrts(ftdi, state)

def set_event_char(ftdi, eventch, enable):
    """set_event_char(context ftdi, unsigned char eventch, unsigned char enable) -> int"""
    return _ftdi1.set_event_char(ftdi, eventch, enable)

def set_error_char(ftdi, errorch, enable):
    """set_error_char(context ftdi, unsigned char errorch, unsigned char enable) -> int"""
    return _ftdi1.set_error_char(ftdi, errorch, enable)

def eeprom_initdefaults(ftdi, manufacturer, product, serial):
    """eeprom_initdefaults(context ftdi, char * manufacturer, char * product, char * serial) -> int"""
    return _ftdi1.eeprom_initdefaults(ftdi, manufacturer, product, serial)

def eeprom_build(ftdi):
    """eeprom_build(context ftdi) -> int"""
    return _ftdi1.eeprom_build(ftdi)

def eeprom_decode(ftdi, verbose):
    """eeprom_decode(context ftdi, int verbose) -> int"""
    return _ftdi1.eeprom_decode(ftdi, verbose)

def set_eeprom_value(ftdi, value_name, value):
    """set_eeprom_value(context ftdi, enum ftdi_eeprom_value value_name, int value) -> int"""
    return _ftdi1.set_eeprom_value(ftdi, value_name, value)

def set_eeprom_buf(ftdi, buf, size):
    """set_eeprom_buf(context ftdi, unsigned char const * buf, int size) -> int"""
    return _ftdi1.set_eeprom_buf(ftdi, buf, size)

def read_eeprom(ftdi):
    """read_eeprom(context) -> (return_code, eeprom)"""
    return _ftdi1.read_eeprom(ftdi)

def write_eeprom(ftdi):
    """write_eeprom(context ftdi) -> int"""
    return _ftdi1.write_eeprom(ftdi)

def erase_eeprom(ftdi):
    """erase_eeprom(context ftdi) -> int"""
    return _ftdi1.erase_eeprom(ftdi)

def write_eeprom_location(ftdi, eeprom_addr, eeprom_val):
    """write_eeprom_location(context ftdi, int eeprom_addr, unsigned short eeprom_val) -> int"""
    return _ftdi1.write_eeprom_location(ftdi, eeprom_addr, eeprom_val)

def get_error_string(ftdi):
    """get_error_string(context ftdi) -> char *"""
    return _ftdi1.get_error_string(ftdi)

_ftdi1.FTDI_MAX_EEPROM_SIZE_swigconstant(_ftdi1)
FTDI_MAX_EEPROM_SIZE = _ftdi1.FTDI_MAX_EEPROM_SIZE

_ftdi1.MAX_POWER_MILLIAMP_PER_UNIT_swigconstant(_ftdi1)
MAX_POWER_MILLIAMP_PER_UNIT = _ftdi1.MAX_POWER_MILLIAMP_PER_UNIT
class eeprom(_object):
    """Proxy of C ftdi_eeprom struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, eeprom, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, eeprom, name)
    __repr__ = _swig_repr
    __swig_setmethods__["vendor_id"] = _ftdi1.eeprom_vendor_id_set
    __swig_getmethods__["vendor_id"] = _ftdi1.eeprom_vendor_id_get
    if _newclass:
        vendor_id = _swig_property(_ftdi1.eeprom_vendor_id_get, _ftdi1.eeprom_vendor_id_set)
    __swig_setmethods__["product_id"] = _ftdi1.eeprom_product_id_set
    __swig_getmethods__["product_id"] = _ftdi1.eeprom_product_id_get
    if _newclass:
        product_id = _swig_property(_ftdi1.eeprom_product_id_get, _ftdi1.eeprom_product_id_set)
    __swig_setmethods__["initialized_for_connected_device"] = _ftdi1.eeprom_initialized_for_connected_device_set
    __swig_getmethods__["initialized_for_connected_device"] = _ftdi1.eeprom_initialized_for_connected_device_get
    if _newclass:
        initialized_for_connected_device = _swig_property(_ftdi1.eeprom_initialized_for_connected_device_get, _ftdi1.eeprom_initialized_for_connected_device_set)
    __swig_setmethods__["self_powered"] = _ftdi1.eeprom_self_powered_set
    __swig_getmethods__["self_powered"] = _ftdi1.eeprom_self_powered_get
    if _newclass:
        self_powered = _swig_property(_ftdi1.eeprom_self_powered_get, _ftdi1.eeprom_self_powered_set)
    __swig_setmethods__["remote_wakeup"] = _ftdi1.eeprom_remote_wakeup_set
    __swig_getmethods__["remote_wakeup"] = _ftdi1.eeprom_remote_wakeup_get
    if _newclass:
        remote_wakeup = _swig_property(_ftdi1.eeprom_remote_wakeup_get, _ftdi1.eeprom_remote_wakeup_set)
    __swig_setmethods__["is_not_pnp"] = _ftdi1.eeprom_is_not_pnp_set
    __swig_getmethods__["is_not_pnp"] = _ftdi1.eeprom_is_not_pnp_get
    if _newclass:
        is_not_pnp = _swig_property(_ftdi1.eeprom_is_not_pnp_get, _ftdi1.eeprom_is_not_pnp_set)
    __swig_setmethods__["suspend_dbus7"] = _ftdi1.eeprom_suspend_dbus7_set
    __swig_getmethods__["suspend_dbus7"] = _ftdi1.eeprom_suspend_dbus7_get
    if _newclass:
        suspend_dbus7 = _swig_property(_ftdi1.eeprom_suspend_dbus7_get, _ftdi1.eeprom_suspend_dbus7_set)
    __swig_setmethods__["in_is_isochronous"] = _ftdi1.eeprom_in_is_isochronous_set
    __swig_getmethods__["in_is_isochronous"] = _ftdi1.eeprom_in_is_isochronous_get
    if _newclass:
        in_is_isochronous = _swig_property(_ftdi1.eeprom_in_is_isochronous_get, _ftdi1.eeprom_in_is_isochronous_set)
    __swig_setmethods__["out_is_isochronous"] = _ftdi1.eeprom_out_is_isochronous_set
    __swig_getmethods__["out_is_isochronous"] = _ftdi1.eeprom_out_is_isochronous_get
    if _newclass:
        out_is_isochronous = _swig_property(_ftdi1.eeprom_out_is_isochronous_get, _ftdi1.eeprom_out_is_isochronous_set)
    __swig_setmethods__["suspend_pull_downs"] = _ftdi1.eeprom_suspend_pull_downs_set
    __swig_getmethods__["suspend_pull_downs"] = _ftdi1.eeprom_suspend_pull_downs_get
    if _newclass:
        suspend_pull_downs = _swig_property(_ftdi1.eeprom_suspend_pull_downs_get, _ftdi1.eeprom_suspend_pull_downs_set)
    __swig_setmethods__["use_serial"] = _ftdi1.eeprom_use_serial_set
    __swig_getmethods__["use_serial"] = _ftdi1.eeprom_use_serial_get
    if _newclass:
        use_serial = _swig_property(_ftdi1.eeprom_use_serial_get, _ftdi1.eeprom_use_serial_set)
    __swig_setmethods__["usb_version"] = _ftdi1.eeprom_usb_version_set
    __swig_getmethods__["usb_version"] = _ftdi1.eeprom_usb_version_get
    if _newclass:
        usb_version = _swig_property(_ftdi1.eeprom_usb_version_get, _ftdi1.eeprom_usb_version_set)
    __swig_setmethods__["use_usb_version"] = _ftdi1.eeprom_use_usb_version_set
    __swig_getmethods__["use_usb_version"] = _ftdi1.eeprom_use_usb_version_get
    if _newclass:
        use_usb_version = _swig_property(_ftdi1.eeprom_use_usb_version_get, _ftdi1.eeprom_use_usb_version_set)
    __swig_setmethods__["max_power"] = _ftdi1.eeprom_max_power_set
    __swig_getmethods__["max_power"] = _ftdi1.eeprom_max_power_get
    if _newclass:
        max_power = _swig_property(_ftdi1.eeprom_max_power_get, _ftdi1.eeprom_max_power_set)
    __swig_setmethods__["manufacturer"] = _ftdi1.eeprom_manufacturer_set
    __swig_getmethods__["manufacturer"] = _ftdi1.eeprom_manufacturer_get
    if _newclass:
        manufacturer = _swig_property(_ftdi1.eeprom_manufacturer_get, _ftdi1.eeprom_manufacturer_set)
    __swig_setmethods__["product"] = _ftdi1.eeprom_product_set
    __swig_getmethods__["product"] = _ftdi1.eeprom_product_get
    if _newclass:
        product = _swig_property(_ftdi1.eeprom_product_get, _ftdi1.eeprom_product_set)
    __swig_setmethods__["serial"] = _ftdi1.eeprom_serial_set
    __swig_getmethods__["serial"] = _ftdi1.eeprom_serial_get
    if _newclass:
        serial = _swig_property(_ftdi1.eeprom_serial_get, _ftdi1.eeprom_serial_set)
    __swig_setmethods__["channel_a_type"] = _ftdi1.eeprom_channel_a_type_set
    __swig_getmethods__["channel_a_type"] = _ftdi1.eeprom_channel_a_type_get
    if _newclass:
        channel_a_type = _swig_property(_ftdi1.eeprom_channel_a_type_get, _ftdi1.eeprom_channel_a_type_set)
    __swig_setmethods__["channel_b_type"] = _ftdi1.eeprom_channel_b_type_set
    __swig_getmethods__["channel_b_type"] = _ftdi1.eeprom_channel_b_type_get
    if _newclass:
        channel_b_type = _swig_property(_ftdi1.eeprom_channel_b_type_get, _ftdi1.eeprom_channel_b_type_set)
    __swig_setmethods__["channel_a_driver"] = _ftdi1.eeprom_channel_a_driver_set
    __swig_getmethods__["channel_a_driver"] = _ftdi1.eeprom_channel_a_driver_get
    if _newclass:
        channel_a_driver = _swig_property(_ftdi1.eeprom_channel_a_driver_get, _ftdi1.eeprom_channel_a_driver_set)
    __swig_setmethods__["channel_b_driver"] = _ftdi1.eeprom_channel_b_driver_set
    __swig_getmethods__["channel_b_driver"] = _ftdi1.eeprom_channel_b_driver_get
    if _newclass:
        channel_b_driver = _swig_property(_ftdi1.eeprom_channel_b_driver_get, _ftdi1.eeprom_channel_b_driver_set)
    __swig_setmethods__["channel_c_driver"] = _ftdi1.eeprom_channel_c_driver_set
    __swig_getmethods__["channel_c_driver"] = _ftdi1.eeprom_channel_c_driver_get
    if _newclass:
        channel_c_driver = _swig_property(_ftdi1.eeprom_channel_c_driver_get, _ftdi1.eeprom_channel_c_driver_set)
    __swig_setmethods__["channel_d_driver"] = _ftdi1.eeprom_channel_d_driver_set
    __swig_getmethods__["channel_d_driver"] = _ftdi1.eeprom_channel_d_driver_get
    if _newclass:
        channel_d_driver = _swig_property(_ftdi1.eeprom_channel_d_driver_get, _ftdi1.eeprom_channel_d_driver_set)
    __swig_setmethods__["channel_a_rs485enable"] = _ftdi1.eeprom_channel_a_rs485enable_set
    __swig_getmethods__["channel_a_rs485enable"] = _ftdi1.eeprom_channel_a_rs485enable_get
    if _newclass:
        channel_a_rs485enable = _swig_property(_ftdi1.eeprom_channel_a_rs485enable_get, _ftdi1.eeprom_channel_a_rs485enable_set)
    __swig_setmethods__["channel_b_rs485enable"] = _ftdi1.eeprom_channel_b_rs485enable_set
    __swig_getmethods__["channel_b_rs485enable"] = _ftdi1.eeprom_channel_b_rs485enable_get
    if _newclass:
        channel_b_rs485enable = _swig_property(_ftdi1.eeprom_channel_b_rs485enable_get, _ftdi1.eeprom_channel_b_rs485enable_set)
    __swig_setmethods__["channel_c_rs485enable"] = _ftdi1.eeprom_channel_c_rs485enable_set
    __swig_getmethods__["channel_c_rs485enable"] = _ftdi1.eeprom_channel_c_rs485enable_get
    if _newclass:
        channel_c_rs485enable = _swig_property(_ftdi1.eeprom_channel_c_rs485enable_get, _ftdi1.eeprom_channel_c_rs485enable_set)
    __swig_setmethods__["channel_d_rs485enable"] = _ftdi1.eeprom_channel_d_rs485enable_set
    __swig_getmethods__["channel_d_rs485enable"] = _ftdi1.eeprom_channel_d_rs485enable_get
    if _newclass:
        channel_d_rs485enable = _swig_property(_ftdi1.eeprom_channel_d_rs485enable_get, _ftdi1.eeprom_channel_d_rs485enable_set)
    __swig_setmethods__["cbus_function"] = _ftdi1.eeprom_cbus_function_set
    __swig_getmethods__["cbus_function"] = _ftdi1.eeprom_cbus_function_get
    if _newclass:
        cbus_function = _swig_property(_ftdi1.eeprom_cbus_function_get, _ftdi1.eeprom_cbus_function_set)
    __swig_setmethods__["high_current"] = _ftdi1.eeprom_high_current_set
    __swig_getmethods__["high_current"] = _ftdi1.eeprom_high_current_get
    if _newclass:
        high_current = _swig_property(_ftdi1.eeprom_high_current_get, _ftdi1.eeprom_high_current_set)
    __swig_setmethods__["high_current_a"] = _ftdi1.eeprom_high_current_a_set
    __swig_getmethods__["high_current_a"] = _ftdi1.eeprom_high_current_a_get
    if _newclass:
        high_current_a = _swig_property(_ftdi1.eeprom_high_current_a_get, _ftdi1.eeprom_high_current_a_set)
    __swig_setmethods__["high_current_b"] = _ftdi1.eeprom_high_current_b_set
    __swig_getmethods__["high_current_b"] = _ftdi1.eeprom_high_current_b_get
    if _newclass:
        high_current_b = _swig_property(_ftdi1.eeprom_high_current_b_get, _ftdi1.eeprom_high_current_b_set)
    __swig_setmethods__["invert"] = _ftdi1.eeprom_invert_set
    __swig_getmethods__["invert"] = _ftdi1.eeprom_invert_get
    if _newclass:
        invert = _swig_property(_ftdi1.eeprom_invert_get, _ftdi1.eeprom_invert_set)
    __swig_setmethods__["group0_drive"] = _ftdi1.eeprom_group0_drive_set
    __swig_getmethods__["group0_drive"] = _ftdi1.eeprom_group0_drive_get
    if _newclass:
        group0_drive = _swig_property(_ftdi1.eeprom_group0_drive_get, _ftdi1.eeprom_group0_drive_set)
    __swig_setmethods__["group0_schmitt"] = _ftdi1.eeprom_group0_schmitt_set
    __swig_getmethods__["group0_schmitt"] = _ftdi1.eeprom_group0_schmitt_get
    if _newclass:
        group0_schmitt = _swig_property(_ftdi1.eeprom_group0_schmitt_get, _ftdi1.eeprom_group0_schmitt_set)
    __swig_setmethods__["group0_slew"] = _ftdi1.eeprom_group0_slew_set
    __swig_getmethods__["group0_slew"] = _ftdi1.eeprom_group0_slew_get
    if _newclass:
        group0_slew = _swig_property(_ftdi1.eeprom_group0_slew_get, _ftdi1.eeprom_group0_slew_set)
    __swig_setmethods__["group1_drive"] = _ftdi1.eeprom_group1_drive_set
    __swig_getmethods__["group1_drive"] = _ftdi1.eeprom_group1_drive_get
    if _newclass:
        group1_drive = _swig_property(_ftdi1.eeprom_group1_drive_get, _ftdi1.eeprom_group1_drive_set)
    __swig_setmethods__["group1_schmitt"] = _ftdi1.eeprom_group1_schmitt_set
    __swig_getmethods__["group1_schmitt"] = _ftdi1.eeprom_group1_schmitt_get
    if _newclass:
        group1_schmitt = _swig_property(_ftdi1.eeprom_group1_schmitt_get, _ftdi1.eeprom_group1_schmitt_set)
    __swig_setmethods__["group1_slew"] = _ftdi1.eeprom_group1_slew_set
    __swig_getmethods__["group1_slew"] = _ftdi1.eeprom_group1_slew_get
    if _newclass:
        group1_slew = _swig_property(_ftdi1.eeprom_group1_slew_get, _ftdi1.eeprom_group1_slew_set)
    __swig_setmethods__["group2_drive"] = _ftdi1.eeprom_group2_drive_set
    __swig_getmethods__["group2_drive"] = _ftdi1.eeprom_group2_drive_get
    if _newclass:
        group2_drive = _swig_property(_ftdi1.eeprom_group2_drive_get, _ftdi1.eeprom_group2_drive_set)
    __swig_setmethods__["group2_schmitt"] = _ftdi1.eeprom_group2_schmitt_set
    __swig_getmethods__["group2_schmitt"] = _ftdi1.eeprom_group2_schmitt_get
    if _newclass:
        group2_schmitt = _swig_property(_ftdi1.eeprom_group2_schmitt_get, _ftdi1.eeprom_group2_schmitt_set)
    __swig_setmethods__["group2_slew"] = _ftdi1.eeprom_group2_slew_set
    __swig_getmethods__["group2_slew"] = _ftdi1.eeprom_group2_slew_get
    if _newclass:
        group2_slew = _swig_property(_ftdi1.eeprom_group2_slew_get, _ftdi1.eeprom_group2_slew_set)
    __swig_setmethods__["group3_drive"] = _ftdi1.eeprom_group3_drive_set
    __swig_getmethods__["group3_drive"] = _ftdi1.eeprom_group3_drive_get
    if _newclass:
        group3_drive = _swig_property(_ftdi1.eeprom_group3_drive_get, _ftdi1.eeprom_group3_drive_set)
    __swig_setmethods__["group3_schmitt"] = _ftdi1.eeprom_group3_schmitt_set
    __swig_getmethods__["group3_schmitt"] = _ftdi1.eeprom_group3_schmitt_get
    if _newclass:
        group3_schmitt = _swig_property(_ftdi1.eeprom_group3_schmitt_get, _ftdi1.eeprom_group3_schmitt_set)
    __swig_setmethods__["group3_slew"] = _ftdi1.eeprom_group3_slew_set
    __swig_getmethods__["group3_slew"] = _ftdi1.eeprom_group3_slew_get
    if _newclass:
        group3_slew = _swig_property(_ftdi1.eeprom_group3_slew_get, _ftdi1.eeprom_group3_slew_set)
    __swig_setmethods__["powersave"] = _ftdi1.eeprom_powersave_set
    __swig_getmethods__["powersave"] = _ftdi1.eeprom_powersave_get
    if _newclass:
        powersave = _swig_property(_ftdi1.eeprom_powersave_get, _ftdi1.eeprom_powersave_set)
    __swig_setmethods__["clock_polarity"] = _ftdi1.eeprom_clock_polarity_set
    __swig_getmethods__["clock_polarity"] = _ftdi1.eeprom_clock_polarity_get
    if _newclass:
        clock_polarity = _swig_property(_ftdi1.eeprom_clock_polarity_get, _ftdi1.eeprom_clock_polarity_set)
    __swig_setmethods__["data_order"] = _ftdi1.eeprom_data_order_set
    __swig_getmethods__["data_order"] = _ftdi1.eeprom_data_order_get
    if _newclass:
        data_order = _swig_property(_ftdi1.eeprom_data_order_get, _ftdi1.eeprom_data_order_set)
    __swig_setmethods__["flow_control"] = _ftdi1.eeprom_flow_control_set
    __swig_getmethods__["flow_control"] = _ftdi1.eeprom_flow_control_get
    if _newclass:
        flow_control = _swig_property(_ftdi1.eeprom_flow_control_get, _ftdi1.eeprom_flow_control_set)
    __swig_setmethods__["size"] = _ftdi1.eeprom_size_set
    __swig_getmethods__["size"] = _ftdi1.eeprom_size_get
    if _newclass:
        size = _swig_property(_ftdi1.eeprom_size_get, _ftdi1.eeprom_size_set)
    __swig_setmethods__["chip"] = _ftdi1.eeprom_chip_set
    __swig_getmethods__["chip"] = _ftdi1.eeprom_chip_get
    if _newclass:
        chip = _swig_property(_ftdi1.eeprom_chip_get, _ftdi1.eeprom_chip_set)
    __swig_setmethods__["buf"] = _ftdi1.eeprom_buf_set
    __swig_getmethods__["buf"] = _ftdi1.eeprom_buf_get
    if _newclass:
        buf = _swig_property(_ftdi1.eeprom_buf_get, _ftdi1.eeprom_buf_set)
    __swig_setmethods__["release_number"] = _ftdi1.eeprom_release_number_set
    __swig_getmethods__["release_number"] = _ftdi1.eeprom_release_number_get
    if _newclass:
        release_number = _swig_property(_ftdi1.eeprom_release_number_get, _ftdi1.eeprom_release_number_set)

    def __init__(self):
        """__init__(ftdi_eeprom self) -> eeprom"""
        this = _ftdi1.new_eeprom()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _ftdi1.delete_eeprom
    __del__ = lambda self: None
eeprom_swigregister = _ftdi1.eeprom_swigregister
eeprom_swigregister(eeprom)


__version__ = get_library_version().version_str

# This file is compatible with both classic and new-style classes.
python-ftdi1 1.2-5build1 / usr / lib / python2.7 / dist-packages / ftdi1.py
