SYMBOL INDEX (1180 symbols across 40 files)

FILE: pyftdi/__init__.py
  class FtdiLogger (line 24) | class FtdiLogger:
    method set_formatter (line 31) | def set_formatter(cls, formatter):
    method get_level (line 37) | def get_level(cls):
    method set_level (line 41) | def set_level(cls, level):

FILE: pyftdi/bin/ftconf.py
  function main (line 27) | def main():

FILE: pyftdi/bin/ftdi_urls.py
  function main (line 19) | def main():

FILE: pyftdi/bin/i2cscan.py
  class I2cBusScanner (line 23) | class I2cBusScanner:
    method scan (line 35) | def scan(cls, url: str, smb_mode: bool = True, force: bool = False) \
  function main (line 87) | def main():

FILE: pyftdi/bin/pyterm.py
  class MiniTerm (line 36) | class MiniTerm:
    method __init__ (line 41) | def __init__(self, device, baudrate=None, parity=None, rtscts=False,
    method run (line 55) | def run(self, fullmode=False, loopback=False, silent=False,
    method _sourcer (line 83) | def _sourcer(self):
    method _get_from_source (line 96) | def _get_from_source(self):
    method _get_from_port (line 105) | def _get_from_port(self):
    method _reader (line 117) | def _reader(self, loopback, getfunc):
    method _writer (line 141) | def _writer(self, fullmode, silent, localecho, crlf=0):
    method _cleanup (line 183) | def _cleanup(self, *args):
    method _open_port (line 211) | def _open_port(device, baudrate, parity, rtscts, debug=False):
  function get_default_device (line 256) | def get_default_device() -> str:
  function main (line 276) | def main():

FILE: pyftdi/bits.py
  class BitSequenceError (line 17) | class BitSequenceError(Exception):
  class BitSequence (line 21) | class BitSequence:
    method __init__ (line 39) | def __init__(self, value: Union['BitSequence', str, int] = None,
    method sequence (line 77) | def sequence(self) -> bytearray:
    method reverse (line 81) | def reverse(self) -> 'BitSequence':
    method invert (line 86) | def invert(self) -> 'BitSequence':
    method append (line 91) | def append(self, seq) -> 'BitSequence':
    method lsr (line 98) | def lsr(self, count: int) -> None:
    method rsr (line 103) | def rsr(self, count: int) -> None:
    method tobit (line 108) | def tobit(self) -> bool:
    method tobyte (line 114) | def tobyte(self, msb: bool = False) -> int:
    method tobytes (line 127) | def tobytes(self, msb: bool = False, msby: bool = False) -> bytearray:
    method _tomutable (line 146) | def _tomutable(value: Union[str, Tuple]) -> List:
    method _init_from_integer (line 159) | def _init_from_integer(self, value: int, msb: bool, length: int) -> None:
    method _init_from_iterable (line 172) | def _init_from_iterable(self, iterable: Iterable, msb: bool) -> None:
    method _init_from_sibling (line 185) | def _init_from_sibling(self, value: 'BitSequence', msb: bool) -> None:
    method _update_length (line 191) | def _update_length(self, length, msb):
    method __iter__ (line 202) | def __iter__(self):
    method __reversed__ (line 205) | def __reversed__(self):
    method __getitem__ (line 208) | def __getitem__(self, index):
    method __setitem__ (line 213) | def __setitem__(self, index, value):
    method __len__ (line 230) | def __len__(self):
    method __eq__ (line 233) | def __eq__(self, other):
    method __ne__ (line 236) | def __ne__(self, other):
    method __le__ (line 239) | def __le__(self, other):
    method __lt__ (line 242) | def __lt__(self, other):
    method __ge__ (line 245) | def __ge__(self, other):
    method __gt__ (line 248) | def __gt__(self, other):
    method _cmp (line 251) | def _cmp(self, other):
    method __repr__ (line 261) | def __repr__(self):
    method __str__ (line 265) | def __str__(self):
    method __int__ (line 277) | def __int__(self):
    method __and__ (line 284) | def __and__(self, other):
    method __or__ (line 292) | def __or__(self, other):
    method __add__ (line 300) | def __add__(self, other):
    method __ilshift__ (line 303) | def __ilshift__(self, count):
    method __irshift__ (line 310) | def __irshift__(self, count):
    method inc (line 317) | def inc(self) -> None:
    method dec (line 325) | def dec(self) -> None:
    method invariant (line 333) | def invariant(self) -> bool:
  class BitZSequence (line 351) | class BitZSequence(BitSequence):
    method __init__ (line 365) | def __init__(self, value=None, msb=False, length=0):
    method invert (line 368) | def invert(self):
    method tobyte (line 373) | def tobyte(self, msb=False):
    method tobytes (line 377) | def tobytes(self, msb=False, msby=False):
    method matches (line 381) | def matches(self, other):
    method _init_from_iterable (line 396) | def _init_from_iterable(self, iterable, msb):
    method __repr__ (line 411) | def __repr__(self):
    method __int__ (line 415) | def __int__(self):
    method __cmp__ (line 421) | def __cmp__(self, other):
    method __and__ (line 431) | def __and__(self, other):
    method __or__ (line 446) | def __or__(self, other):
    method __rand__ (line 461) | def __rand__(self, other):
    method __ror__ (line 464) | def __ror__(self, other):
    method __radd__ (line 467) | def __radd__(self, other):
  class BitField (line 471) | class BitField:
    method __init__ (line 480) | def __init__(self, value=0):
    method to_seq (line 483) | def to_seq(self, msb=0, lsb=0):
    method __getitem__ (line 495) | def __getitem__(self, index):
    method __setitem__ (line 509) | def __setitem__(self, index, value):
    method __int__ (line 530) | def __int__(self):
    method __str__ (line 533) | def __str__(self):

FILE: pyftdi/doc/conf.py
  function read (line 22) | def read(where, *parts):
  function find_meta (line 31) | def find_meta(meta):
  function setup (line 108) | def setup(app):

FILE: pyftdi/eeprom.py
  class FtdiEepromError (line 26) | class FtdiEepromError(FtdiError):
  class Hex2Int (line 30) | class Hex2Int(int):
    method __str__ (line 32) | def __str__(self):
  class Hex4Int (line 36) | class Hex4Int(int):
    method __str__ (line 38) | def __str__(self):
  class FtdiEeprom (line 42) | class FtdiEeprom:
    method __init__ (line 102) | def __init__(self):
    method __getattr__ (line 116) | def __getattr__(self, name):
    method eeprom_sizes (line 122) | def eeprom_sizes(cls) -> List[int]:
    method open (line 130) | def open(self, device: Union[str, UsbDevice],
    method close (line 162) | def close(self) -> None:
    method connect (line 171) | def connect(self, ftdi: Ftdi, ignore: bool = False) -> None:
    method device_version (line 190) | def device_version(self) -> int:
    method size (line 202) | def size(self) -> int:
    method default_size (line 215) | def default_size(self) -> int:
    method storage_size (line 236) | def storage_size(self) -> int:
    method data (line 252) | def data(self) -> bytes:
    method properties (line 261) | def properties(self) -> Set[str]:
    method is_empty (line 271) | def is_empty(self) -> bool:
    method cbus_pins (line 285) | def cbus_pins(self) -> List[int]:
    method cbus_mask (line 295) | def cbus_mask(self) -> int:
    method has_mirroring (line 313) | def has_mirroring(self) -> bool:
    method mirror_sector (line 323) | def mirror_sector(self) -> int:
    method is_mirroring_enabled (line 334) | def is_mirroring_enabled(self) -> bool:
    method enable_mirroring (line 341) | def enable_mirroring(self, enable: bool) -> None:
    method save_config (line 358) | def save_config(self, file: TextIO) -> None:
    method load_config (line 379) | def load_config(self, file: TextIO, section: Optional[str] = None) -> ...
    method set_serial_number (line 451) | def set_serial_number(self, serial: str) -> None:
    method set_manufacturer_name (line 457) | def set_manufacturer_name(self, manufacturer: str) -> None:
    method set_product_name (line 462) | def set_product_name(self, product: str) -> None:
    method set_property (line 467) | def set_property(self, name: str, value: Union[str, int, bool],
    method erase (line 677) | def erase(self, erase_byte: Optional[int] = 0xFF) -> None:
    method initialize (line 686) | def initialize(self) -> None:
    method sync (line 703) | def sync(self) -> None:
    method dump_config (line 711) | def dump_config(self, file: Optional[BinaryIO] = None) -> None:
    method commit (line 721) | def commit(self, dry_run: bool = True, no_crc: bool = False) -> bool:
    method reset_device (line 749) | def reset_device(self):
    method set_test_mode (line 753) | def set_test_mode(self, enable: bool):
    method _validate_string (line 758) | def _validate_string(cls, string):
    method _update_var_string (line 764) | def _update_var_string(self, name: str, value: str) -> None:
    method _generate_var_strings (line 776) | def _generate_var_strings(self, fill=True) -> None:
    method _sync_eeprom (line 828) | def _sync_eeprom(self, no_crc: bool = False):
    method _compute_crc (line 843) | def _compute_crc(self, eeprom: Union[bytes, bytearray], check=False):
    method _update_crc (line 868) | def _update_crc(self):
    method _compute_size (line 877) | def _compute_size(self, eeprom: Union[bytes, bytearray]) \
    method _read_eeprom (line 895) | def _read_eeprom(self) -> bytes:
    method _decode_eeprom (line 913) | def _decode_eeprom(self):
    method _decode_string (line 957) | def _decode_string(self, offset):
    method _set_cbus_func (line 967) | def _set_cbus_func(self, cpin: int, value: str,
    method _filter_cbus_func_x900 (line 1010) | def _filter_cbus_func_x900(cls, cpin: int, value: str):
    method _filter_cbus_func_x600 (line 1025) | def _filter_cbus_func_x600(cls, cpin: int, value: str):
    method _set_bus_control (line 1031) | def _set_bus_control(self, bus: str, control: str,
    method _set_group (line 1040) | def _set_group(self, group: int, control: str,
    method _set_bus_control_230x (line 1048) | def _set_bus_control_230x(self, bus: str, control: str,
    method _set_group_x232h (line 1055) | def _set_group_x232h(self, group: int, control: str, value: str,
    method _set_bus_xprop (line 1066) | def _set_bus_xprop(self, offset: int, high_nibble: bool, control: str,
    method _set_invert (line 1112) | def _set_invert(self, name, value, out):
    method _decode_x (line 1127) | def _decode_x(self):
    method _decode_232h (line 1151) | def _decode_232h(self):
    method _decode_232r (line 1182) | def _decode_232r(self):
    method _decode_2232h (line 1207) | def _decode_2232h(self):
    method _decode_4232h (line 1215) | def _decode_4232h(self):
    method _decode_x232h (line 1227) | def _decode_x232h(self, cfg):

FILE: pyftdi/ftdi.py
  class FtdiError (line 27) | class FtdiError(IOError):
  class FtdiFeatureError (line 31) | class FtdiFeatureError(FtdiError):
  class FtdiMpsseError (line 35) | class FtdiMpsseError(FtdiFeatureError):
  class FtdiEepromError (line 39) | class FtdiEepromError(FtdiError):
  class Ftdi (line 43) | class Ftdi:
    class BitMode (line 130) | class BitMode(IntEnum):
    method __init__ (line 315) | def __init__(self):
    method create_from_url (line 345) | def create_from_url(cls, url: str) -> 'Ftdi':
    method list_devices (line 358) | def list_devices(cls, url: Optional[str] = None) -> \
    method show_devices (line 370) | def show_devices(cls, url: Optional[str] = None,
    method get_identifiers (line 384) | def get_identifiers(cls, url: str) -> Tuple[UsbDeviceDescriptor, int]:
    method get_device (line 394) | def get_device(cls, url: str) -> UsbDevice:
    method add_custom_vendor (line 404) | def add_custom_vendor(cls, vid: int, vidname: str = '') -> None:
    method add_custom_product (line 420) | def add_custom_product(cls, vid: int, pid: int, pidname: str = '') -> ...
    method decode_modem_status (line 441) | def decode_modem_status(cls, value: bytes, error_only: bool = False) -> \
    method find_all (line 459) | def find_all(vps: Sequence[Tuple[int, int]], nocache: bool = False) -> \
    method is_connected (line 475) | def is_connected(self) -> bool:
    method open_from_url (line 482) | def open_from_url(self, url: str) -> None:
    method open (line 491) | def open(self, vendor: int, product: int, bus: Optional[int] = None,
    method open_from_device (line 524) | def open_from_device(self, device: UsbDevice,
    method close (line 558) | def close(self, freeze: bool = False) -> None:
    method reset (line 588) | def reset(self, usb_reset: bool = False) -> None:
    method open_mpsse_from_url (line 603) | def open_mpsse_from_url(self, url: str, direction: int = 0x0,
    method open_mpsse (line 632) | def open_mpsse(self, vendor: int, product: int, bus: Optional[int] = N...
    method open_mpsse_from_device (line 686) | def open_mpsse_from_device(self, device: UsbDevice,
    method open_bitbang_from_url (line 762) | def open_bitbang_from_url(self, url: str, direction: int = 0x0,
    method open_bitbang (line 787) | def open_bitbang(self, vendor: int, product: int,
    method open_bitbang_from_device (line 822) | def open_bitbang_from_device(self, device: UsbDevice,
    method usb_path (line 863) | def usb_path(self) -> Tuple[int, int, int]:
    method device_version (line 874) | def device_version(self) -> int:
    method ic_name (line 886) | def ic_name(self) -> str:
    method device_port_count (line 899) | def device_port_count(self) -> int:
    method port_index (line 909) | def port_index(self) -> int:
    method port_width (line 919) | def port_width(self) -> int:
    method has_mpsse (line 934) | def has_mpsse(self) -> bool:
    method has_wide_port (line 945) | def has_wide_port(self) -> bool:
    method has_cbus (line 954) | def has_cbus(self) -> bool:
    method has_drivezero (line 972) | def has_drivezero(self) -> bool:
    method is_legacy (line 985) | def is_legacy(self) -> bool:
    method is_H_series (line 997) | def is_H_series(self) -> bool:
    method is_mpsse (line 1008) | def is_mpsse(self) -> bool:
    method is_mpsse_interface (line 1015) | def is_mpsse_interface(self, interface: int) -> bool:
    method is_bitbang_enabled (line 1030) | def is_bitbang_enabled(self) -> bool:
    method is_eeprom_internal (line 1046) | def is_eeprom_internal(self) -> bool:
    method max_eeprom_size (line 1054) | def max_eeprom_size(self) -> int:
    method frequency_max (line 1068) | def frequency_max(self) -> float:
    method fifo_sizes (line 1076) | def fifo_sizes(self) -> Tuple[int, int]:
    method mpsse_bit_delay (line 1088) | def mpsse_bit_delay(self) -> float:
    method baudrate (line 1100) | def baudrate(self) -> int:
    method usb_dev (line 1106) | def usb_dev(self) -> UsbDevice:
    method set_baudrate (line 1111) | def set_baudrate(self, baudrate: int, constrain: bool = True) -> int:
    method set_frequency (line 1139) | def set_frequency(self, frequency: float) -> float:
    method purge_rx_buffer (line 1154) | def purge_rx_buffer(self) -> None:
    method purge_tx_buffer (line 1165) | def purge_tx_buffer(self) -> None:
    method purge_buffers (line 1171) | def purge_buffers(self) -> None:
    method write_data_set_chunksize (line 1176) | def write_data_set_chunksize(self, chunksize: int = 0) -> None:
    method write_data_get_chunksize (line 1191) | def write_data_get_chunksize(self) -> int:
    method read_data_set_chunksize (line 1198) | def read_data_set_chunksize(self, chunksize: int = 0) -> None:
    method read_data_get_chunksize (line 1225) | def read_data_get_chunksize(self) -> int:
    method set_bitmode (line 1232) | def set_bitmode(self, bitmask: int, mode: 'Ftdi.BitMode') -> None:
    method read_pins (line 1244) | def read_pins(self) -> int:
    method set_cbus_direction (line 1255) | def set_cbus_direction(self, mask: int, direction: int) -> None:
    method get_cbus_gpio (line 1268) | def get_cbus_gpio(self) -> int:
    method set_cbus_gpio (line 1287) | def set_cbus_gpio(self, pins: int) -> None:
    method set_latency_timer (line 1309) | def set_latency_timer(self, latency: int):
    method get_latency_timer (line 1326) | def get_latency_timer(self) -> int:
    method poll_modem_status (line 1336) | def poll_modem_status(self) -> int:
    method modem_status (line 1356) | def modem_status(self) -> Tuple[str, ...]:
    method set_flowctrl (line 1366) | def set_flowctrl(self, flowctrl: str) -> None:
    method set_dtr (line 1423) | def set_dtr(self, state: bool) -> None:
    method set_rts (line 1432) | def set_rts(self, state: bool) -> None:
    method set_dtr_rts (line 1441) | def set_dtr_rts(self, dtr: bool, rts: bool) -> None:
    method set_break (line 1453) | def set_break(self, break_: bool) -> None:
    method set_event_char (line 1468) | def set_event_char(self, eventch: int, enable: bool) -> None:
    method set_error_char (line 1476) | def set_error_char(self, errorch: int, enable: bool) -> None:
    method set_line_property (line 1484) | def set_line_property(self, bits: int, stopbit: Union[int, float],
    method enable_adaptive_clock (line 1549) | def enable_adaptive_clock(self, enable: bool = True) -> None:
    method enable_3phase_clock (line 1564) | def enable_3phase_clock(self, enable: bool = True) -> None:
    method enable_drivezero_mode (line 1583) | def enable_drivezero_mode(self, lines: int) -> None:
    method enable_loopback_mode (line 1602) | def enable_loopback_mode(self, loopback: bool = False) -> None:
    method calc_eeprom_checksum (line 1611) | def calc_eeprom_checksum(self, data: Union[bytes, bytearray]) -> int:
    method read_eeprom (line 1636) | def read_eeprom(self, addr: int = 0, length: Optional[int] = None,
    method write_eeprom (line 1674) | def write_eeprom(self, addr: int, data: Union[bytes, bytearray],
    method overwrite_eeprom (line 1734) | def overwrite_eeprom(self, data: Union[bytes, bytearray],
    method write_data (line 1753) | def write_data(self, data: Union[bytes, bytearray]) -> int:
    method read_data_bytes (line 1783) | def read_data_bytes(self, size: int, attempt: int = 1,
    method read_data (line 1912) | def read_data(self, size: int) -> bytes:
    method get_cts (line 1923) | def get_cts(self) -> bool:
    method get_dsr (line 1931) | def get_dsr(self) -> bool:
    method get_ri (line 1939) | def get_ri(self) -> bool:
    method get_cd (line 1947) | def get_cd(self) -> bool:
    method set_dynamic_latency (line 1955) | def set_dynamic_latency(self, lmin: int, lmax: int,
    method validate_mpsse (line 1996) | def validate_mpsse(self) -> None:
    method get_error_string (line 2008) | def get_error_string(cls) -> str:
    method _set_interface (line 2017) | def _set_interface(self, config: UsbConfiguration, ifnum: int):
    method _reset_usb_device (line 2039) | def _reset_usb_device(self) -> None:
    method _is_pyusb_handle_active (line 2043) | def _is_pyusb_handle_active(self) -> bool:
    method _reset_device (line 2050) | def _reset_device(self):
    method _ctrl_transfer_out (line 2056) | def _ctrl_transfer_out(self, reqtype: int, value: int, data: bytes = b...
    method _ctrl_transfer_in (line 2065) | def _ctrl_transfer_in(self, reqtype: int, length: int):
    method _write (line 2074) | def _write(self, data: Union[bytes, bytearray]) -> int:
    method _read (line 2088) | def _read(self) -> bytes:
    method _adapt_latency (line 2101) | def _adapt_latency(self, payload_detected: bool) -> None:
    method _check_eeprom_size (line 2126) | def _check_eeprom_size(self, eeprom_size: Optional[int]) -> int:
    method _write_eeprom_raw (line 2139) | def _write_eeprom_raw(self, addr: int, data: Union[bytes, bytearray],
    method _get_max_packet_size (line 2179) | def _get_max_packet_size(self) -> int:
    method _convert_baudrate_legacy (line 2189) | def _convert_baudrate_legacy(self, baudrate: int) -> Tuple[int, int, i...
    method _convert_baudrate (line 2210) | def _convert_baudrate(self, baudrate: int) -> Tuple[int, int, int]:
    method _set_baudrate (line 2253) | def _set_baudrate(self, baudrate: int, constrain: bool) -> int:
    method _set_frequency (line 2273) | def _set_frequency(self, frequency: float) -> float:
    method __get_timeouts (line 2320) | def __get_timeouts(self) -> Tuple[int, int]:
    method __set_timeouts (line 2323) | def __set_timeouts(self, timeouts: Tuple[int, int]):

FILE: pyftdi/gpio.py
  class GpioException (line 16) | class GpioException(FtdiError):
  class GpioPort (line 21) | class GpioPort:
  class GpioBaseController (line 26) | class GpioBaseController(GpioPort):
    method __init__ (line 32) | def __init__(self):
    method ftdi (line 40) | def ftdi(self) -> Ftdi:
    method is_connected (line 48) | def is_connected(self) -> bool:
    method configure (line 55) | def configure(self, url: str, direction: int = 0,
    method close (line 78) | def close(self, freeze: bool = False) -> None:
    method get_gpio (line 90) | def get_gpio(self) -> GpioPort:
    method direction (line 101) | def direction(self) -> int:
    method pins (line 110) | def pins(self) -> int:
    method all_pins (line 121) | def all_pins(self) -> int:
    method width (line 132) | def width(self) -> int:
    method frequency (line 140) | def frequency(self) -> float:
    method set_frequency (line 146) | def set_frequency(self, frequency: Union[int, float]) -> None:
    method set_direction (line 154) | def set_direction(self, pins: int, direction: int) -> None:
    method _configure (line 168) | def _configure(self, url: str, direction: int,
    method _update_direction (line 172) | def _update_direction(self) -> None:
  class GpioAsyncController (line 176) | class GpioAsyncController(GpioBaseController):
    method read (line 197) | def read(self, readlen: int = 1, peek: Optional[bool] = None,
    method write (line 254) | def write(self, out: Union[bytes, bytearray, int]) -> None:
    method set_frequency (line 276) | def set_frequency(self, frequency: Union[int, float]) -> None:
    method _configure (line 301) | def _configure(self, url: str, direction: int,
    method _update_direction (line 325) | def _update_direction(self) -> None:
  class GpioSyncController (line 338) | class GpioSyncController(GpioBaseController):
    method exchange (line 357) | def exchange(self, out: Union[bytes, bytearray]) -> bytes:
    method set_frequency (line 380) | def set_frequency(self, frequency: Union[int, float]) -> None:
    method _configure (line 388) | def _configure(self, url: str, direction: int,
    method _update_direction (line 412) | def _update_direction(self) -> None:
  class GpioMpsseController (line 416) | class GpioMpsseController(GpioBaseController):
    method read (line 430) | def read(self, readlen: int = 1, peek: Optional[bool] = None) \
    method write (line 457) | def write(self, out: Union[bytes, bytearray, Iterable[int], int]) -> N...
    method set_frequency (line 477) | def set_frequency(self, frequency: Union[int, float]) -> None:
    method _update_direction (line 482) | def _update_direction(self) -> None:
    method _configure (line 487) | def _configure(self, url: str, direction: int,
    method _read_mpsse (line 498) | def _read_mpsse(self, count: int) -> Tuple[int]:
    method _write_mpsse (line 518) | def _write_mpsse(self,

FILE: pyftdi/i2c.py
  class I2cIOError (line 19) | class I2cIOError(IOError):
  class I2cNackError (line 23) | class I2cNackError(I2cIOError):
  class I2cTimeoutError (line 27) | class I2cTimeoutError(TimeoutError):
  class I2cPort (line 31) | class I2cPort:
    method __init__ (line 54) | def __init__(self, controller: 'I2cController', address: int):
    method configure_register (line 61) | def configure_register(self,
    method shift_address (line 74) | def shift_address(self, offset: int):
    method read (line 80) | def read(self, readlen: int = 0, relax: bool = True,
    method write (line 95) | def write(self, out: Union[bytes, bytearray, Iterable[int]],
    method read_from (line 109) | def read_from(self, regaddr: int, readlen: int = 0,
    method write_to (line 125) | def write_to(self, regaddr: int,
    method exchange (line 141) | def exchange(self, out: Union[bytes, bytearray, Iterable[int]] = b'',
    method poll (line 158) | def poll(self, write: bool = False,
    method poll_cond (line 171) | def poll_cond(self, width: int, mask: int, value: int, count: int,
    method flush (line 199) | def flush(self) -> None:
    method frequency (line 205) | def frequency(self) -> float:
    method address (line 211) | def address(self) -> int:
    method _make_buffer (line 215) | def _make_buffer(self, regaddr: int,
  class I2cGpioPort (line 225) | class I2cGpioPort:
    method __init__ (line 250) | def __init__(self, controller: 'I2cController'):
    method pins (line 255) | def pins(self) -> int:
    method all_pins (line 266) | def all_pins(self) -> int:
    method width (line 277) | def width(self) -> int:
    method direction (line 287) | def direction(self) -> int:
    method read (line 296) | def read(self, with_output: bool = False) -> int:
    method write (line 304) | def write(self, value: int) -> None:
    method set_direction (line 311) | def set_direction(self, pins: int, direction: int) -> None:
  class I2cController (line 325) | class I2cController:
    method __init__ (line 365) | def __init__(self):
    method set_retry_count (line 395) | def set_retry_count(self, count: int) -> None:
    method configure (line 404) | def configure(self, url: Union[str, UsbDevice],
    method force_clock_mode (line 508) | def force_clock_mode(self, enable: bool) -> None:
    method close (line 526) | def close(self, freeze: bool = False) -> None:
    method terminate (line 536) | def terminate(self) -> None:
    method get_port (line 543) | def get_port(self, address: int) -> I2cPort:
    method get_gpio (line 556) | def get_gpio(self) -> I2cGpioPort:
    method ftdi (line 569) | def ftdi(self) -> Ftdi:
    method configured (line 577) | def configured(self) -> bool:
    method validate_address (line 585) | def validate_address(cls, address: Optional[int]) -> None:
    method frequency_max (line 598) | def frequency_max(self) -> float:
    method frequency (line 606) | def frequency(self) -> float:
    method direction (line 614) | def direction(self) -> int:
    method gpio_pins (line 624) | def gpio_pins(self) -> int:
    method gpio_all_pins (line 636) | def gpio_all_pins(self) -> int:
    method width (line 649) | def width(self) -> int:
    method read (line 656) | def read(self, address: Optional[int], readlen: int = 1,
    method write (line 698) | def write(self, address: Optional[int],
    method exchange (line 739) | def exchange(self, address: Optional[int],
    method poll (line 792) | def poll(self, address: int, write: bool = False,
    method poll_cond (line 823) | def poll_cond(self, address: int, fmt: str, mask: int, value: int,
    method flush (line 877) | def flush(self) -> None:
    method read_gpio (line 886) | def read_gpio(self, with_output: bool = False) -> int:
    method write_gpio (line 899) | def write_gpio(self, value: int) -> None:
    method set_gpio_direction (line 916) | def set_gpio_direction(self, pins: int, direction: int) -> None:
    method _set_gpio_direction (line 926) | def _set_gpio_direction(self, width: int, pins: int,
    method _data_lo (line 939) | def _data_lo(self) -> Tuple[int]:
    method _clk_lo_data_hi (line 945) | def _clk_lo_data_hi(self) -> Tuple[int]:
    method _clk_lo_data_input (line 951) | def _clk_lo_data_input(self) -> Tuple[int]:
    method _clk_lo_data_lo (line 957) | def _clk_lo_data_lo(self) -> Tuple[int]:
    method _clk_input_data_input (line 963) | def _clk_input_data_input(self) -> Tuple[int]:
    method _idle (line 969) | def _idle(self) -> Tuple[int]:
    method _start (line 975) | def _start(self) -> Tuple[int]:
    method _stop (line 980) | def _stop(self) -> Tuple[int]:
    method _compute_delay_cycles (line 986) | def _compute_delay_cycles(self, value: Union[int, float]) -> int:
    method _read_raw (line 992) | def _read_raw(self, read_high: bool) -> int:
    method _write_raw (line 1010) | def _write_raw(self, data: int, write_high: bool):
    method _do_prolog (line 1023) | def _do_prolog(self, i2caddress: Optional[int]) -> None:
    method _do_epilog (line 1037) | def _do_epilog(self) -> None:
    method _send_check_ack (line 1047) | def _send_check_ack(self, cmd: bytearray):
    method _i2c_write_data (line 1067) | def _i2c_write_data(self, cmd: bytearray):
    method _i2c_read_data_bytes (line 1073) | def _i2c_read_data_bytes(self, readlen: int, attempt: int = 1,
    method _do_read (line 1083) | def _do_read(self, readlen: int) -> bytearray:
    method _do_write (line 1163) | def _do_write(self, out: Union[bytes, bytearray, Iterable[int]]):

FILE: pyftdi/jtag.py
  class JtagError (line 18) | class JtagError(Exception):
  class JtagState (line 22) | class JtagState:
    method __init__ (line 25) | def __init__(self, name: str, modes: Tuple[str, str]):
    method __str__ (line 30) | def __str__(self):
    method __repr__ (line 33) | def __repr__(self):
    method setx (line 36) | def setx(self, fstate: 'JtagState', tstate: 'JtagState'):
    method getx (line 39) | def getx(self, event):
    method is_of (line 43) | def is_of(self, mode: str) -> bool:
  class JtagStateMachine (line 47) | class JtagStateMachine:
    method __init__ (line 50) | def __init__(self):
    method __getitem__ (line 92) | def __getitem__(self, name: str) -> JtagState:
    method state (line 95) | def state(self) -> JtagState:
    method state_of (line 98) | def state_of(self, mode: str) -> bool:
    method reset (line 101) | def reset(self):
    method find_path (line 104) | def find_path(self, target: Union[JtagState, str],
    method get_events (line 144) | def get_events(cls, path):
    method handle_events (line 157) | def handle_events(self, events):
  class JtagController (line 162) | class JtagController:
    method __init__ (line 174) | def __init__(self, trst: bool = False, frequency: float = 3.0E6):
    method configure (line 190) | def configure(self, url: str) -> None:
    method close (line 198) | def close(self, freeze: bool = False) -> None:
    method purge (line 210) | def purge(self) -> None:
    method reset (line 213) | def reset(self, sync: bool = False) -> None:
    method sync (line 238) | def sync(self) -> None:
    method write_tms (line 245) | def write_tms(self, tms: BitSequence,
    method read (line 268) | def read(self, length: int) -> BitSequence:
    method write (line 281) | def write(self, out: Union[BitSequence, str], use_last: bool = True):
    method write_with_read (line 300) | def write_with_read(self, out: BitSequence,
    method read_from_buffer (line 330) | def read_from_buffer(self, length) -> BitSequence:
    method ftdi (line 360) | def ftdi(self) -> Ftdi:
    method _stack_cmd (line 367) | def _stack_cmd(self, cmd: Union[bytes, bytearray]):
    method _read_bits (line 377) | def _read_bits(self, length: int):
    method _write_bits (line 391) | def _write_bits(self, out: BitSequence) -> None:
    method _read_bytes (line 399) | def _read_bytes(self, length: int) -> BitSequence:
    method _write_bytes (line 413) | def _write_bytes(self, out: BitSequence):
    method _write_bytes_raw (line 423) | def _write_bytes_raw(self, out: BitSequence):
  class JtagEngine (line 432) | class JtagEngine:
    method __init__ (line 435) | def __init__(self, trst: bool = False, frequency: float = 3E06):
    method state_machine (line 441) | def state_machine(self):
    method controller (line 445) | def controller(self):
    method configure (line 448) | def configure(self, url: str) -> None:
    method close (line 452) | def close(self, freeze: bool = False) -> None:
    method purge (line 460) | def purge(self) -> None:
    method reset (line 464) | def reset(self) -> None:
    method write_tms (line 469) | def write_tms(self, out, should_read=False) -> None:
    method read (line 473) | def read(self, length):
    method write (line 477) | def write(self, out, use_last=False) -> None:
    method get_available_statenames (line 481) | def get_available_statenames(self):
    method change_state (line 485) | def change_state(self, statename) -> None:
    method go_idle (line 496) | def go_idle(self) -> None:
    method write_ir (line 500) | def write_ir(self, instruction) -> None:
    method capture_ir (line 506) | def capture_ir(self) -> None:
    method write_dr (line 510) | def write_dr(self, data) -> None:
    method read_dr (line 516) | def read_dr(self, length: int) -> BitSequence:
    method capture_dr (line 523) | def capture_dr(self) -> None:
    method sync (line 527) | def sync(self) -> None:
    method shift_register (line 530) | def shift_register(self, out: BitSequence) -> BitSequence:
    method shift_and_update_register (line 545) | def shift_and_update_register(self, out: BitSequence) -> BitSequence:
  class JtagTool (line 578) | class JtagTool:
    method __init__ (line 581) | def __init__(self, engine):
    method idcode (line 584) | def idcode(self) -> None:
    method preload (line 589) | def preload(self, bsdl, data) -> None:
    method sample (line 595) | def sample(self, bsdl):
    method extest (line 602) | def extest(self, bsdl) -> None:
    method readback (line 606) | def readback(self, bsdl):
    method detect_register_size (line 611) | def detect_register_size(self) -> int:

FILE: pyftdi/misc.py
  function hexdump (line 28) | def hexdump(data: Union[bytes, bytearray, Iterable[int]],
  function hexline (line 77) | def hexline(data: Union[bytes, bytearray, Iterable[int]],
  function to_int (line 104) | def to_int(value: Union[int, str]) -> int:
  function to_bool (line 135) | def to_bool(value: Union[int, bool, str], permissive: bool = True,
  function to_bps (line 166) | def to_bps(value: str) -> int:
  function xor (line 191) | def xor(_a_: bool, _b_: bool) -> bool:
  function is_iterable (line 202) | def is_iterable(obj: Any) -> bool:
  function pretty_size (line 217) | def pretty_size(size, sep: str = ' ',
  function add_custom_devices (line 247) | def add_custom_devices(ftdicls=None,
  function show_call_stack (line 301) | def show_call_stack():
  class classproperty (line 309) | class classproperty(property):
    method __get__ (line 312) | def __get__(self, obj: Any, objtype=None) -> Any:
  class EasyDict (line 316) | class EasyDict(dict):
    method __init__ (line 320) | def __init__(self, dictionary=None, **kwargs):
    method __getattr__ (line 326) | def __getattr__(self, name):
    method __setattr__ (line 333) | def __setattr__(self, name, value):
    method copy (line 337) | def copy(cls, dictionary):
    method mirror (line 347) | def mirror(self) -> 'EasyDict':

FILE: pyftdi/serialext/__init__.py
  function touch (line 30) | def touch():

FILE: pyftdi/serialext/logger.py
  class SerialLogger (line 22) | class SerialLogger:
    method __init__ (line 26) | def __init__(self, *args, **kwargs):
    method open (line 39) | def open(self,):
    method close (line 43) | def close(self):
    method read (line 48) | def read(self, size=1):
    method write (line 53) | def write(self, data):
    method flush (line 58) | def flush(self):
    method reset_input_buffer (line 62) | def reset_input_buffer(self):
    method reset_output_buffer (line 66) | def reset_output_buffer(self):
    method send_break (line 70) | def send_break(self, duration=0.25):
    method _update_break_state (line 74) | def _update_break_state(self):
    method _update_rts_state (line 78) | def _update_rts_state(self):
    method _update_dtr_state (line 82) | def _update_dtr_state(self):
    method cts (line 87) | def cts(self):
    method dsr (line 93) | def dsr(self):
    method ri (line 99) | def ri(self):
    method cd (line 105) | def cd(self):
    method in_waiting (line 110) | def in_waiting(self):
    method _print (line 115) | def _print(self, header, string=None):
    method _log_init (line 124) | def _log_init(self, *args, **kwargs):
    method _log_open (line 132) | def _log_open(self):
    method _log_close (line 138) | def _log_close(self):
    method _log_read (line 144) | def _log_read(self, data):
    method _log_write (line 150) | def _log_write(self, data):
    method _log_flush (line 156) | def _log_flush(self):
    method _log_reset (line 162) | def _log_reset(self, type_):
    method _log_waiting (line 168) | def _log_waiting(self, count):
    method _log_signal (line 174) | def _log_signal(self, name, value):

FILE: pyftdi/serialext/protocol_ftdi.py
  class FtdiSerial (line 20) | class FtdiSerial(SerialBase):
    method open (line 31) | def open(self):
    method close (line 44) | def close(self):
    method read (line 51) | def read(self, size=1):
    method write (line 72) | def write(self, data):
    method flush (line 76) | def flush(self):
    method reset_input_buffer (line 80) | def reset_input_buffer(self):
    method reset_output_buffer (line 84) | def reset_output_buffer(self):
    method send_break (line 89) | def send_break(self, duration=0.25):
    method _update_break_state (line 95) | def _update_break_state(self):
    method _update_rts_state (line 99) | def _update_rts_state(self):
    method _update_dtr_state (line 103) | def _update_dtr_state(self):
    method ftdi (line 108) | def ftdi(self) -> Ftdi:
    method usb_path (line 116) | def usb_path(self):
    method cts (line 128) | def cts(self):
    method dsr (line 133) | def dsr(self):
    method ri (line 138) | def ri(self):
    method cd (line 143) | def cd(self):
    method in_waiting (line 148) | def in_waiting(self):
    method out_waiting (line 154) | def out_waiting(self):
    method fifoSizes (line 159) | def fifoSizes(self):
    method _reconfigure_port (line 163) | def _reconfigure_port(self):
    method _set_open_state (line 184) | def _set_open_state(self, open_):
  class Serial (line 190) | class Serial(FtdiSerial, RawIOBase):
    method __init__ (line 194) | def __init__(self, *args, **kwargs):

FILE: pyftdi/serialext/protocol_unix.py
  class SerialExceptionWithErrno (line 29) | class SerialExceptionWithErrno(SerialException):
    method __init__ (line 32) | def __init__(self, message, errno=None):
  class SocketSerial (line 37) | class SocketSerial(SerialBase):
    method _reconfigure_port (line 48) | def _reconfigure_port(self):
    method open (line 51) | def open(self):
    method close (line 78) | def close(self):
    method in_waiting (line 91) | def in_waiting(self):
    method read (line 95) | def read(self, size=1):
    method write (line 117) | def write(self, data):
    method flush (line 144) | def flush(self):
    method reset_input_buffer (line 148) | def reset_input_buffer(self):
    method reset_output_buffer (line 151) | def reset_output_buffer(self):
    method send_break (line 155) | def send_break(self, duration=0.25):
    method _update_break_state (line 158) | def _update_break_state(self):
    method _update_rts_state (line 161) | def _update_rts_state(self):
    method _update_dtr_state (line 164) | def _update_dtr_state(self):
    method setDTR (line 167) | def setDTR(self, value=1):
    method cts (line 171) | def cts(self):
    method dsr (line 176) | def dsr(self):
    method ri (line 181) | def ri(self):
    method cd (line 186) | def cd(self):
    method nonblocking (line 192) | def nonblocking(self):
    method dump (line 198) | def dump(self, enable):
    method _set_open_state (line 203) | def _set_open_state(self, open_):
  class Serial (line 212) | class Serial(SocketSerial, RawIOBase):

FILE: pyftdi/serialext/tests/rl.py
  function main (line 15) | def main():

FILE: pyftdi/spi.py
  class SpiIOError (line 19) | class SpiIOError(FtdiError):
  class SpiPort (line 23) | class SpiPort:
    method __init__ (line 44) | def __init__(self, controller: 'SpiController', cs: int, cs_hold: int ...
    method exchange (line 53) | def exchange(self, out: Union[bytes, bytearray, Iterable[int]] = b'',
    method read (line 81) | def read(self, readlen: int = 0, start: bool = True, stop: bool = True,
    method write (line 104) | def write(self, out: Union[bytes, bytearray, Iterable[int]],
    method flush (line 126) | def flush(self) -> None:
    method set_frequency (line 130) | def set_frequency(self, frequency: float):
    method set_mode (line 137) | def set_mode(self, mode: int, cs_hold: Optional[int] = None) -> None:
    method force_select (line 163) | def force_select(self, level: Optional[bool] = None,
    method frequency (line 202) | def frequency(self) -> float:
    method cs (line 207) | def cs(self) -> int:
    method mode (line 215) | def mode(self) -> int:
  class SpiGpioPort (line 223) | class SpiGpioPort:
    method __init__ (line 251) | def __init__(self, controller: 'SpiController'):
    method pins (line 256) | def pins(self) -> int:
    method all_pins (line 267) | def all_pins(self) -> int:
    method width (line 278) | def width(self) -> int:
    method direction (line 288) | def direction(self) -> int:
    method read (line 297) | def read(self, with_output: bool = False) -> int:
    method write (line 305) | def write(self, value: int) -> None:
    method set_direction (line 312) | def set_direction(self, pins: int, direction: int) -> None:
  class SpiController (line 321) | class SpiController:
    method __init__ (line 337) | def __init__(self, cs_count: int = 1, turbo: bool = True):
    method configure (line 356) | def configure(self, url: Union[str, UsbDevice],
    method close (line 438) | def close(self, freeze: bool = False) -> None:
    method terminate (line 449) | def terminate(self) -> None:
    method get_port (line 456) | def get_port(self, cs: int, freq: Optional[float] = None,
    method get_gpio (line 483) | def get_gpio(self) -> SpiGpioPort:
    method ftdi (line 496) | def ftdi(self) -> Ftdi:
    method configured (line 504) | def configured(self) -> bool:
    method frequency_max (line 512) | def frequency_max(self) -> float:
    method frequency (line 520) | def frequency(self) -> float:
    method direction (line 528) | def direction(self):
    method channels (line 538) | def channels(self) -> int:
    method active_channels (line 547) | def active_channels(self) -> Set[int]:
    method gpio_pins (line 555) | def gpio_pins(self):
    method gpio_all_pins (line 567) | def gpio_all_pins(self):
    method width (line 580) | def width(self):
    method is_inverted_cpha_supported (line 588) | def is_inverted_cpha_supported(self) -> bool:
    method exchange (line 595) | def exchange(self, frequency: float,
    method force_control (line 639) | def force_control(self, frequency: float, sequence: bytes) -> None:
    method flush (line 649) | def flush(self) -> None:
    method read_gpio (line 655) | def read_gpio(self, with_output: bool = False) -> int:
    method write_gpio (line 668) | def write_gpio(self, value: int) -> None:
    method set_gpio_direction (line 685) | def set_gpio_direction(self, pins: int, direction: int) -> None:
    method _set_gpio_direction (line 695) | def _set_gpio_direction(self, width: int, pins: int,
    method _read_raw (line 707) | def _read_raw(self, read_high: bool) -> int:
    method _write_raw (line 727) | def _write_raw(self, data: int, write_high: bool) -> None:
    method _force (line 742) | def _force(self, frequency: float, sequence: bytes):
    method _exchange_half_duplex (line 760) | def _exchange_half_duplex(self, frequency: float,
    method _exchange_full_duplex (line 869) | def _exchange_full_duplex(self, frequency: float,
    method _flush (line 947) | def _flush(self) -> None:

FILE: pyftdi/term.py
  function call (line 21) | def call():
  class Terminal (line 26) | class Terminal:
    method __init__ (line 141) | def __init__(self):
    method init (line 144) | def init(self, fullterm: bool) -> None:
    method reset (line 165) | def reset(self) -> None:
    method is_term (line 174) | def is_term() -> bool:
    method is_colorterm (line 180) | def is_colorterm() -> bool:
    method getkey (line 187) | def getkey(cls) -> bytes:
    method getch_to_escape (line 206) | def getch_to_escape(cls, char: bytes) -> bytes:

FILE: pyftdi/tests/backend/consts.py
  class UsbConstants (line 17) | class UsbConstants:
    method __init__ (line 33) | def __init__(self):
    method descriptors (line 51) | def descriptors(self):
    method _load_constants (line 55) | def _load_constants(cls, prefix: str, reverse=False):
    method _mask (line 76) | def _mask(cls, mapping: dict) -> int:
    method is_req_out (line 82) | def is_req_out(self, reqtype: int) -> str:
    method dec_req_ctrl (line 85) | def dec_req_ctrl(self, reqtype: int) -> str:
    method dec_req_type (line 88) | def dec_req_type(self, reqtype: int) -> str:
    method dec_req_rcpt (line 91) | def dec_req_rcpt(self, reqtype: int) -> str:
    method dec_req_name (line 94) | def dec_req_name(self, reqtype: int, request: int) -> str:
    method dec_desc_type (line 101) | def dec_desc_type(self, desctype: int) -> str:
  class FtdiConstants (line 105) | class FtdiConstants:
    method __init__ (line 110) | def __init__(self):
    method _load_constants (line 115) | def _load_constants(cls, prefix: str, reverse=False):
    method get_name (line 145) | def get_name(self, prefix: str, value: int) -> str:
    method get_value (line 153) | def get_value(self, prefix: str, name: str) -> str:
    method dec_req_name (line 161) | def dec_req_name(self, request: int) -> str:

FILE: pyftdi/tests/backend/ftdivirt.py
  class Pipe (line 30) | class Pipe:
    method __init__ (line 36) | def __init__(self):
    method close (line 40) | def close(self):
    method read (line 48) | def read(self, count: int) -> bytes:
    method write (line 51) | def write(self, buf: bytes) -> None:
    method ep_out (line 55) | def ep_out(self) -> 'Pipe':
    method ep_in (line 60) | def ep_in(self) -> 'Pipe':
    method __getattr__ (line 64) | def __getattr__(self, name):
  class Fifo (line 77) | class Fifo:
    method __init__ (line 80) | def __init__(self, size: int = 0):
  class VirtualFtdiPin (line 87) | class VirtualFtdiPin:
    class Function (line 91) | class Function(IntEnum):
    method __init__ (line 98) | def __init__(self, port, position):
    method connect_to (line 106) | def connect_to(self, pin: 'VirtualFtdiPin') -> None:
    method disconnect (line 112) | def disconnect(self, pin: 'VirtualFtdiPin') -> None:
    method set_function (line 115) | def set_function(self,
    method set (line 124) | def set(self, source: bool, signal: bool) -> None:
    method read (line 138) | def read(self, count: int) -> bytes:
    method push_to_pin (line 146) | def push_to_pin(self, buf: bytes) -> None:
    method write (line 156) | def write(self, buf: bytes) -> None:
    method port (line 165) | def port(self) -> 'VirtFtdiPort':
    method connection (line 169) | def connection(self) -> Optional['VirtualFtdiPin']:
    method is_connected (line 173) | def is_connected(self) -> bool:
    method position (line 177) | def position(self) -> int:
    method direction (line 181) | def direction(self) -> bool:
    method signal (line 185) | def signal(self) -> Optional[bool]:
  class VirtFtdiPort (line 193) | class VirtFtdiPort:
    class Fifos (line 204) | class Fifos(NamedTuple):
    class BitMode (line 209) | class BitMode(IntEnum):
    class Command (line 257) | class Command(IntEnum):
    method __init__ (line 263) | def __init__(self, parent: 'VirtFtdi', iface: int):
    method close (line 301) | def close(self, freeze: bool = False) -> None:
    method terminate (line 321) | def terminate(self):
    method __getitem__ (line 324) | def __getitem__(self, index: int) -> VirtualFtdiPin:
    method iface (line 334) | def iface(self) -> int:
    method baudrate (line 338) | def baudrate(self) -> int:
    method width (line 342) | def width(self) -> int:
    method direction (line 346) | def direction(self) -> int:
    method gpio (line 350) | def gpio(self) -> int:
    method cbus (line 354) | def cbus(self) -> Tuple[int, int]:
    method cbus (line 363) | def cbus(self, cbus: int) -> None:
    method write (line 367) | def write(self, data: array, timeout: int) -> int:
    method read (line 385) | def read(self, buff: array, timeout: int) -> int:
    method set_io (line 408) | def set_io(self, pin: VirtualFtdiPin, signal: bool) -> None:
    method update_gpio (line 417) | def update_gpio(self, mpsse: VirtMpsseEngine, source: bool,
    method modem_status (line 423) | def modem_status(self) -> Tuple[int, int]:
    method control_reset (line 461) | def control_reset(self, wValue: int, wIndex: int,
    method control_set_bitmode (line 489) | def control_set_bitmode(self, wValue: int, wIndex: int,
    method control_set_latency_timer (line 546) | def control_set_latency_timer(self, wValue: int, wIndex: int,
    method control_set_event_char (line 550) | def control_set_event_char(self, wValue: int, wIndex: int,
    method control_set_error_char (line 557) | def control_set_error_char(self, wValue: int, wIndex: int,
    method control_read_pins (line 564) | def control_read_pins(self, wValue: int, wIndex: int,
    method control_set_baudrate (line 576) | def control_set_baudrate(self, wValue: int, wIndex: int,
    method control_set_data (line 607) | def control_set_data(self, wValue: int, wIndex: int,
    method control_set_flow_ctrl (line 611) | def control_set_flow_ctrl(self, wValue: int, wIndex: int,
    method control_poll_modem_status (line 615) | def control_poll_modem_status(self, wValue: int, wIndex: int,
    method write_from_pin (line 622) | def write_from_pin(self, pin: int, buf: bytes) -> None:
    method write_from_mpsse (line 631) | def write_from_mpsse(self, mpsse: VirtMpsseEngine, buf: bytes) -> None:
    method _update_gpio (line 642) | def _update_gpio(self, source: bool, gpio: int) -> None:
    method _decode_cbus_x1000 (line 656) | def _decode_cbus_x1000(self) -> None:
    method _decode_cbus_x0900 (line 681) | def _decode_cbus_x0900(self) -> None:
    method _decode_cbus_x0600 (line 718) | def _decode_cbus_x0600(self) -> None:
    method _cbus_write (line 745) | def _cbus_write(self, cbus: int) -> None:
    method _cbus_read (line 769) | def _cbus_read(self) -> Tuple[int, int]:
    method _rx_worker (line 793) | def _rx_worker(self):
    method _tx_worker (line 866) | def _tx_worker(self):
    method _tx_worker_generate (line 914) | def _tx_worker_generate(self, bitmode) -> None:
  class VirtFtdi (line 934) | class VirtFtdi:
    class Properties (line 941) | class Properties(NamedTuple):
    method __init__ (line 976) | def __init__(self, version: int, bus: int, address: int,
    method close (line 987) | def close(self, freeze: bool = False) -> None:
    method terminate (line 991) | def terminate(self):
    method version (line 995) | def version(self) -> int:
    method bus (line 999) | def bus(self) -> int:
    method address (line 1003) | def address(self) -> int:
    method properties (line 1007) | def properties(self) -> 'VirtFtdi.Properties':
    method is_mpsse_device (line 1011) | def is_mpsse_device(self) -> bool:
    method is_hispeed_device (line 1019) | def is_hispeed_device(self) -> bool:
    method is_x_series (line 1027) | def is_x_series(self) -> bool:
    method apply_eeprom_config (line 1034) | def apply_eeprom_config(self, devdesc: dict,
    method control (line 1038) | def control(self, dev_handle: 'VirtDeviceHandle', bmRequestType: int,
    method write (line 1075) | def write(self, dev_handle: 'VirtDeviceHandle', ep: int, intf: int,
    method read (line 1079) | def read(self, dev_handle: 'VirtDeviceHandle', ep: int, intf: int,
    method get_port (line 1083) | def get_port(self, iface: int):
    method eeprom (line 1088) | def eeprom(self) -> bytes:
    method eeprom (line 1092) | def eeprom(self, value: bytes):
    method _build_eeprom (line 1098) | def _build_eeprom(cls, version, eeprom: Optional[dict]) -> bytearray:
    method _checksum_eeprom (line 1130) | def _checksum_eeprom(self, data: bytearray) -> int:
    method _load_eeprom (line 1147) | def _load_eeprom(self, devdesc: dict, cfgdescs: Sequence[dict]) -> None:
    method _decode_eeprom_string (line 1173) | def _decode_eeprom_string(self, offset):
    method _control_read_eeprom (line 1182) | def _control_read_eeprom(self, wValue: int, wIndex: int,
    method _control_write_eeprom (line 1199) | def _control_write_eeprom(self, wValue: int, wIndex: int,
    method _control_set_baudrate (line 1217) | def _control_set_baudrate(self, wValue: int, wIndex: int,

FILE: pyftdi/tests/backend/loader.py
  class VirtLoader (line 27) | class VirtLoader:
    method __init__ (line 31) | def __init__(self):
    method load (line 36) | def load(self, yamlfp: BinaryIO) -> None:
    method unload (line 52) | def unload(self) -> None:
    method get_virtual_ftdi (line 65) | def get_virtual_ftdi(self, bus, address):
    method eeprom_backup (line 69) | def eeprom_backup(self) -> bytes:
    method _validate (line 74) | def _validate(self):
    method _build_root (line 104) | def _build_root(self, backend, container):
    method _build_device (line 121) | def _build_device(self, container):
    method _build_device_descriptor (line 190) | def _build_device_descriptor(self, container) -> dict:
    method _build_configuration (line 213) | def _build_configuration(self, container):
    method _build_config_descriptor (line 238) | def _build_config_descriptor(self, container) -> dict:
    method _build_interfaces (line 269) | def _build_interfaces(self, container):
    method _build_alternative (line 300) | def _build_alternative(self, container):
    method _build_interface_descriptor (line 326) | def _build_interface_descriptor(self, container) -> dict:
    method _build_endpoint (line 342) | def _build_endpoint(self, container):
    method _build_endpoint_descriptor (line 358) | def _build_endpoint_descriptor(self, container) -> dict:

FILE: pyftdi/tests/backend/mpsse.py
  class VirtMpsseTracer (line 17) | class VirtMpsseTracer(FtdiMpsseTracer):
    method __init__ (line 21) | def __init__(self, port: 'VirtFtdiPort', version: int):
    method _get_engine (line 26) | def _get_engine(self, iface: int):
  class VirtMpsseEngine (line 38) | class VirtMpsseEngine(FtdiMpsseEngine):
    method __init__ (line 44) | def __init__(self, tracer: VirtMpsseTracer, port: 'VirtFtdiPort'):
    method send (line 53) | def send(self, buf: Union[bytes, bytearray]) -> None:
    method reply (line 60) | def reply(self) -> None:
    method _cmd_get_bits_low (line 65) | def _cmd_get_bits_low(self):
    method _cmd_get_bits_high (line 72) | def _cmd_get_bits_high(self):
    method _cmd_set_bits_low (line 79) | def _cmd_set_bits_low(self):
    method _cmd_set_bits_high (line 93) | def _cmd_set_bits_high(self):

FILE: pyftdi/tests/backend/usbvirt.py
  class VirtEndpoint (line 31) | class VirtEndpoint:
    method __init__ (line 37) | def __init__(self, defs: dict,
    method build_strings (line 55) | def build_strings(self, func):
    method get_length (line 58) | def get_length(self) -> int:
    method __getattr__ (line 61) | def __getattr__(self, name):
  class VirtInterface (line 65) | class VirtInterface:
    method __init__ (line 71) | def __init__(self, defs: dict, extra: Optional[bytes] = None):
    method add_endpoint (line 92) | def add_endpoint(self, endpoint: VirtEndpoint):
    method update_number (line 97) | def update_number(self, number: int) -> None:
    method endpoints (line 101) | def endpoints(self):
    method build_strings (line 104) | def build_strings(self, func):
    method add_bulk_pair (line 111) | def add_bulk_pair(self):
    method get_length (line 126) | def get_length(self) -> int:
    method num_altsetting (line 135) | def num_altsetting(self):
    method __getitem__ (line 138) | def __getitem__(self, item):
    method __getattr__ (line 143) | def __getattr__(self, name):
  class VirtConfiguration (line 147) | class VirtConfiguration:
    method __init__ (line 153) | def __init__(self, defs: dict, extra: Optional[bytes] = None):
    method add_interface (line 171) | def add_interface(self, interface: VirtInterface):
    method build_strings (line 176) | def build_strings(self, func):
    method update (line 181) | def update(self):
    method get_length (line 186) | def get_length(self) -> int:
    method __getattr__ (line 192) | def __getattr__(self, name):
  class VirtDevice (line 196) | class VirtDevice:
    method __init__ (line 204) | def __init__(self, defs: dict, **kwargs):
    method close (line 242) | def close(self, freeze: bool = False):
    method terminate (line 245) | def terminate(self):
    method add_configuration (line 248) | def add_configuration(self, config: VirtConfiguration):
    method build (line 253) | def build(self):
    method build_strings (line 257) | def build_strings(self, func):
    method ftdi (line 263) | def ftdi(self) -> VirtFtdi:
    method _store_strings (line 267) | def _store_strings(obj, desc, ignore=None):
    method get_string (line 276) | def get_string(self, type_: int, index: int) -> str:
    method __getattr__ (line 298) | def __getattr__(self, name):
  class VirtDeviceHandle (line 302) | class VirtDeviceHandle(EasyDict):
    method __init__ (line 306) | def __init__(self, dev, handle):
  class VirtBackend (line 312) | class VirtBackend(IBackend):
    method __init__ (line 319) | def __init__(self):
    method add_device (line 325) | def add_device(self, device: VirtDevice):
    method flush_devices (line 328) | def flush_devices(self):
    method create_loader (line 334) | def create_loader(cls) -> 'VirtLoader':
    method devices (line 349) | def devices(self) -> List[VirtDevice]:
    method get_virtual_ftdi (line 352) | def get_virtual_ftdi(self, bus: int, address: int) -> VirtFtdi:
    method enumerate_devices (line 358) | def enumerate_devices(self) -> VirtDevice:
    method open_device (line 361) | def open_device(self, dev: VirtDevice) -> VirtDeviceHandle:
    method close_device (line 367) | def close_device(self, dev_handle: VirtDeviceHandle) -> None:
    method claim_interface (line 370) | def claim_interface(self, dev_handle: VirtDeviceHandle, intf: int) \
    method release_interface (line 375) | def release_interface(self, dev_handle: VirtDeviceHandle, intf: int) \
    method get_configuration (line 380) | def get_configuration(self,
    method set_configuration (line 385) | def set_configuration(self, dev_handle: VirtDeviceHandle,
    method get_device_descriptor (line 390) | def get_device_descriptor(self, dev: VirtDevice) -> EasyDict:
    method get_configuration_descriptor (line 393) | def get_configuration_descriptor(self, dev: VirtDevice, config: int) \
    method get_interface_descriptor (line 397) | def get_interface_descriptor(self, dev: VirtDevice,
    method get_endpoint_descriptor (line 404) | def get_endpoint_descriptor(self, dev: VirtDevice,
    method ctrl_transfer (line 413) | def ctrl_transfer(self,
    method bulk_write (line 432) | def bulk_write(self, dev_handle: VirtDeviceHandle, ep: int, intf: int,
    method bulk_read (line 440) | def bulk_read(self, dev_handle: VirtDeviceHandle, ep: int, intf: int,
    method _ctrl_standard (line 447) | def _ctrl_standard(self,
  function get_backend (line 486) | def get_backend(*_):

FILE: pyftdi/tests/bits.py
  class BitSequenceTestCase (line 22) | class BitSequenceTestCase(TestCase):
    method setUp (line 24) | def setUp(self):
    method test_bitwise_ops (line 40) | def test_bitwise_ops(self):
    method test_cmp (line 67) | def test_cmp(self):
    method test_representation (line 83) | def test_representation(self):
    method test_init (line 103) | def test_init(self):
    method test_conversion (line 152) | def test_conversion(self):
    method test_misc (line 163) | def test_misc(self):
    method test_rotations (line 196) | def test_rotations(self):
    method test_concat (line 205) | def test_concat(self):
  function suite (line 213) | def suite():

FILE: pyftdi/tests/cbus.py
  class CbusOutputGpioTestCase (line 23) | class CbusOutputGpioTestCase(TestCase):
    method setUpClass (line 27) | def setUpClass(cls):
    method test_gpio (line 31) | def test_gpio(self):
  class CbusInputGpioTestCase (line 65) | class CbusInputGpioTestCase(TestCase):
    method setUpClass (line 69) | def setUpClass(cls):
    method test_gpio (line 73) | def test_gpio(self):
  function suite (line 107) | def suite():
  function main (line 120) | def main():

FILE: pyftdi/tests/eeprom.py
  class EepromTestCase (line 24) | class EepromTestCase(TestCase):
    method setUpClass (line 28) | def setUpClass(cls):
    method setUp (line 33) | def setUp(self):
    method tearDown (line 49) | def tearDown(self):
    method test_eeprom_read (line 53) | def test_eeprom_read(self):
    method test_eeprom_write_reject (line 79) | def test_eeprom_write_reject(self):
    method test_eeprom_write (line 92) | def test_eeprom_write(self):
  function suite (line 98) | def suite():
  function main (line 104) | def main():

FILE: pyftdi/tests/eeprom_mock.py
  class FtdiTestCase (line 26) | class FtdiTestCase:
    method setUpClass (line 37) | def setUpClass(cls):
    method tearDownClass (line 43) | def tearDownClass(cls):
    method setUp (line 47) | def setUp(self):
  class EepromMirrorTestCase (line 51) | class EepromMirrorTestCase(FtdiTestCase):
    method setUpClass (line 60) | def setUpClass(cls):
    method test_mirror_properties (line 72) | def test_mirror_properties(self):
    method test_mirror_manufacturer (line 95) | def test_mirror_manufacturer(self):
    method test_mirror_product (line 107) | def test_mirror_product(self):
    method test_mirror_serial (line 119) | def test_mirror_serial(self):
    method test_varstr_combinations (line 131) | def test_varstr_combinations(self):
    method test_compute_size_detects_mirror (line 165) | def test_compute_size_detects_mirror(self):
    method _check_for_mirrored_eeprom_contents (line 188) | def _check_for_mirrored_eeprom_contents(self, eeprom: FtdiEeprom):
  class NonMirroredEepromTestCase (line 201) | class NonMirroredEepromTestCase(FtdiTestCase):
    method setUpClass (line 210) | def setUpClass(cls):
    method test_mirror_properties (line 222) | def test_mirror_properties(self):
    method test_no_mirror_manufacturer (line 251) | def test_no_mirror_manufacturer(self):
    method test_no_mirror_product (line 262) | def test_no_mirror_product(self):
    method test_mirror_serial (line 273) | def test_mirror_serial(self):
    method test_varstr_combinations (line 284) | def test_varstr_combinations(self):
    method test_compute_size_does_not_mirror (line 318) | def test_compute_size_does_not_mirror(self):
    method _check_for_non_mirrored_eeprom_contents (line 339) | def _check_for_non_mirrored_eeprom_contents(self, eeprom: FtdiEeprom):
  class EepromMirrorFt232hTestCase (line 350) | class EepromMirrorFt232hTestCase(EepromMirrorTestCase, TestCase):
  class EepromMirrorFt2232hTestCase (line 354) | class EepromMirrorFt2232hTestCase(EepromMirrorTestCase, TestCase):
  class EepromMirrorFt4232hTestCase (line 358) | class EepromMirrorFt4232hTestCase(EepromMirrorTestCase, TestCase):
  class EepromMirrorFt232rTestCase (line 362) | class EepromMirrorFt232rTestCase(NonMirroredEepromTestCase, TestCase):
  class EepromMirrorFt230xTestCase (line 367) | class EepromMirrorFt230xTestCase(NonMirroredEepromTestCase, TestCase):
  class EepromNonMirroredFt232hTestCase (line 372) | class EepromNonMirroredFt232hTestCase(NonMirroredEepromTestCase, TestCase):
  class EepromNonMirroredFt2232hTestCase (line 377) | class EepromNonMirroredFt2232hTestCase(NonMirroredEepromTestCase, TestCa...
  class EepromNonMirroredFt4232hTestCase (line 382) | class EepromNonMirroredFt4232hTestCase(NonMirroredEepromTestCase, TestCa...
  function suite (line 387) | def suite():
  function virtualize (line 409) | def virtualize():
  function setup_module (line 427) | def setup_module():
  function main (line 449) | def main():

FILE: pyftdi/tests/ftdi.py
  class FtdiTestCase (line 24) | class FtdiTestCase(TestCase):
    method test_multiple_interface (line 27) | def test_multiple_interface(self):
  class HotplugTestCase (line 42) | class HotplugTestCase(TestCase):
    method test_hotplug_discovery (line 44) | def test_hotplug_discovery(self):
  class ResetTestCase (line 63) | class ResetTestCase(TestCase):
    method test_simple_reset (line 65) | def test_simple_reset(self):
    method test_dual_if_reset (line 79) | def test_dual_if_reset(self):
  class DisconnectTestCase (line 115) | class DisconnectTestCase(TestCase):
    method test_close_on_disconnect (line 119) | def test_close_on_disconnect(self):
  function suite (line 153) | def suite():

FILE: pyftdi/tests/gpio.py
  class FtdiTestCase (line 31) | class FtdiTestCase(TestCase):
    method setUpClass (line 36) | def setUpClass(cls):
    method tearDownClass (line 42) | def tearDownClass(cls):
    method setUp (line 46) | def setUp(self):
  class GpioAsyncTestCase (line 51) | class GpioAsyncTestCase(FtdiTestCase):
    method setUpClass (line 72) | def setUpClass(cls):
    method test_gpio_freeze (line 100) | def test_gpio_freeze(self):
    method test_gpio_values (line 134) | def test_gpio_values(self):
    method test_gpio_initial (line 177) | def test_gpio_initial(self):
    method test_gpio_loopback (line 195) | def test_gpio_loopback(self):
    method test_gpio_baudate (line 230) | def test_gpio_baudate(self):
  class GpioSyncTestCase (line 255) | class GpioSyncTestCase(FtdiTestCase):
    method setUpClass (line 276) | def setUpClass(cls):
    method test_gpio_values (line 304) | def test_gpio_values(self):
    method test_gpio_baudate (line 332) | def test_gpio_baudate(self):
  class GpioMultiportTestCase (line 355) | class GpioMultiportTestCase(FtdiTestCase):
    method setUpClass (line 377) | def setUpClass(cls):
    method test_gpio_peek (line 403) | def test_gpio_peek(self):
    method test_gpio_stream (line 420) | def test_gpio_stream(self):
    method test_direction (line 456) | def test_direction(self):
  class GpioMpsseTestCase (line 488) | class GpioMpsseTestCase(FtdiTestCase):
    method setUpClass (line 517) | def setUpClass(cls):
    method test_default_gpio (line 548) | def test_default_gpio(self):
    method test_peek_gpio (line 567) | def test_peek_gpio(self):
    method test_stream_gpio (line 586) | def test_stream_gpio(self):
  function suite (line 608) | def suite():
  function virtualize (line 614) | def virtualize():
  function setup_module (line 631) | def setup_module():
  function main (line 653) | def main():

FILE: pyftdi/tests/i2c.py
  class I2cTca9555TestCase (line 26) | class I2cTca9555TestCase(TestCase):
    method test (line 30) | def test(self):
    method _open (line 37) | def _open(self):
    method _read_it (line 42) | def _read_it(self):
    method _write_it (line 46) | def _write_it(self):
    method _close (line 52) | def _close(self):
  class I2cAccelTestCase (line 57) | class I2cAccelTestCase(TestCase):
    method test (line 61) | def test(self):
    method _open (line 67) | def _open(self):
    method _read_device_id (line 72) | def _read_device_id(self):
    method _close (line 79) | def _close(self):
  class I2cReadTestCase (line 84) | class I2cReadTestCase(TestCase):
    method test (line 88) | def test(self):
    method _open (line 94) | def _open(self):
    method _read (line 99) | def _read(self):
    method _close (line 106) | def _close(self):
  class I2cEepromTestCase (line 111) | class I2cEepromTestCase(TestCase):
    method setUpClass (line 117) | def setUpClass(cls):
    method setUp (line 122) | def setUp(self):
    method tearDown (line 127) | def tearDown(self):
    method test_short (line 130) | def test_short(self):
    method test_long (line 139) | def test_long(self):
  class I2cReadGpioTestCase (line 154) | class I2cReadGpioTestCase(TestCase):
    method test (line 171) | def test(self):
    method _open (line 178) | def _open(self):
    method _execute_sequence (line 191) | def _execute_sequence(self):
    method _execute_interleave (line 207) | def _execute_interleave(self):
    method _close (line 223) | def _close(self):
  class I2cClockStrechingGpioTestCase (line 228) | class I2cClockStrechingGpioTestCase(TestCase):
    method test (line 233) | def test(self):
  class I2cDualMasterTestCase (line 241) | class I2cDualMasterTestCase(TestCase):
    method test (line 246) | def test(self):
  class I2cIssue143TestCase (line 258) | class I2cIssue143TestCase(TestCase):
    method test (line 262) | def test(self):
  function suite (line 280) | def suite():
  function main (line 305) | def main():

FILE: pyftdi/tests/jtag.py
  class JtagTestCase (line 27) | class JtagTestCase(TestCase):
    method setUp (line 29) | def setUp(self):
    method tearDown (line 36) | def tearDown(self):
    method test_idcode_reset (line 39) | def test_idcode_reset(self):
    method test_idcode_sequence (line 46) | def test_idcode_sequence(self):
    method test_idcode_shift_register (line 54) | def test_idcode_shift_register(self):
    method test_bypass_shift_register (line 67) | def test_bypass_shift_register(self):
    method _test_detect_ir_length (line 81) | def _test_detect_ir_length(self):
  function suite (line 88) | def suite():

FILE: pyftdi/tests/mockusb.py
  class FtdiTestCase (line 35) | class FtdiTestCase(TestCase):
    method setUpClass (line 40) | def setUpClass(cls):
    method tearDownClass (line 45) | def tearDownClass(cls):
    method setUp (line 49) | def setUp(self):
  class MockUsbToolsTestCase (line 54) | class MockUsbToolsTestCase(FtdiTestCase):
    method setUpClass (line 59) | def setUpClass(cls):
    method test_enumerate (line 64) | def test_enumerate(self):
    method test_device (line 71) | def test_device(self):
    method test_string (line 82) | def test_string(self):
    method test_list_devices (line 91) | def test_list_devices(self):
  class MockFtdiDiscoveryTestCase (line 132) | class MockFtdiDiscoveryTestCase(FtdiTestCase):
    method setUpClass (line 138) | def setUpClass(cls):
    method test_list_devices (line 143) | def test_list_devices(self):
  class MockSimpleDeviceTestCase (line 175) | class MockSimpleDeviceTestCase(FtdiTestCase):
    method setUpClass (line 180) | def setUpClass(cls):
    method test_enumerate (line 185) | def test_enumerate(self):
  class MockDualDeviceTestCase (line 201) | class MockDualDeviceTestCase(FtdiTestCase):
    method setUpClass (line 206) | def setUpClass(cls):
    method test_enumerate (line 211) | def test_enumerate(self):
  class MockTwoPortDeviceTestCase (line 228) | class MockTwoPortDeviceTestCase(FtdiTestCase):
    method setUpClass (line 233) | def setUpClass(cls):
    method test_enumerate (line 238) | def test_enumerate(self):
  class MockFourPortDeviceTestCase (line 255) | class MockFourPortDeviceTestCase(FtdiTestCase):
    method setUpClass (line 260) | def setUpClass(cls):
    method test_enumerate (line 265) | def test_enumerate(self):
  class MockManyDevicesTestCase (line 282) | class MockManyDevicesTestCase(FtdiTestCase):
    method setUpClass (line 287) | def setUpClass(cls):
    method test_enumerate (line 292) | def test_enumerate(self):
  class MockSimpleDirectTestCase (line 322) | class MockSimpleDirectTestCase(FtdiTestCase):
    method setUpClass (line 327) | def setUpClass(cls):
    method test_open_close (line 332) | def test_open_close(self):
    method test_open_bitbang (line 339) | def test_open_bitbang(self):
    method test_open_mpsse (line 345) | def test_open_mpsse(self):
  class MockSimpleMpsseTestCase (line 353) | class MockSimpleMpsseTestCase(FtdiTestCase):
    method setUpClass (line 358) | def setUpClass(cls):
    method test_open_close (line 363) | def test_open_close(self):
    method test_open_bitbang (line 370) | def test_open_bitbang(self):
    method test_open_mpsse (line 376) | def test_open_mpsse(self):
  class MockSimpleGpioTestCase (line 383) | class MockSimpleGpioTestCase(FtdiTestCase):
    method tearDown (line 387) | def tearDown(self):
    method _test_gpio (line 390) | def _test_gpio(self):
    method test_baudrate (line 409) | def test_baudrate(self):
  class MockSimpleUartTestCase (line 429) | class MockSimpleUartTestCase(FtdiTestCase):
    method tearDown (line 433) | def tearDown(self):
    method test_uart (line 436) | def test_uart(self):
    method test_uart_loopback (line 456) | def test_uart_loopback(self):
    method test_baudrate_fs_dev (line 473) | def test_baudrate_fs_dev(self):
    method test_baudrate_hs_dev (line 490) | def test_baudrate_hs_dev(self):
  class MockRawExtEepromTestCase (line 508) | class MockRawExtEepromTestCase(FtdiTestCase):
    method setUpClass (line 513) | def setUpClass(cls):
    method _restore_eeprom (line 518) | def _restore_eeprom(self, ftdi):
    method test_dump (line 527) | def test_dump(self):
    method test_random_access_read (line 539) | def test_random_access_read(self):
    method test_randow_access_write (line 564) | def test_randow_access_write(self):
  class MockRawIntEepromTestCase (line 607) | class MockRawIntEepromTestCase(FtdiTestCase):
    method setUpClass (line 612) | def setUpClass(cls):
    method test_descriptor_update (line 617) | def test_descriptor_update(self):
    method test_eeprom_read (line 628) | def test_eeprom_read(self):
  class MockCBusEepromTestCase (line 637) | class MockCBusEepromTestCase(FtdiTestCase):
    method tearDown (line 641) | def tearDown(self):
    method test_ft230x (line 644) | def test_ft230x(self):
    method test_ft232h (line 685) | def test_ft232h(self):
  class MockCbusGpioTestCase (line 717) | class MockCbusGpioTestCase(FtdiTestCase):
    method tearDown (line 721) | def tearDown(self):
    method test_230x (line 724) | def test_230x(self):
    method test_lc231x (line 771) | def test_lc231x(self):
  function suite (line 818) | def suite():
  function setup_module (line 824) | def setup_module():
  function main (line 853) | def main():

FILE: pyftdi/tests/spi.py
  class SpiDataFlashTest (line 24) | class SpiDataFlashTest:
    method __init__ (line 29) | def __init__(self):
    method open (line 32) | def open(self):
    method read_jedec_id (line 38) | def read_jedec_id(self):
    method close (line 45) | def close(self):
  class SpiAccelTest (line 50) | class SpiAccelTest:
    method __init__ (line 55) | def __init__(self):
    method open (line 58) | def open(self):
    method read_device_id (line 64) | def read_device_id(self):
    method close (line 71) | def close(self):
  class SpiRfda2125Test (line 76) | class SpiRfda2125Test:
    method __init__ (line 82) | def __init__(self):
    method open (line 86) | def open(self):
    method change_attenuation (line 93) | def change_attenuation(self, value):
    method close (line 99) | def close(self):
  class SpiTestCase (line 104) | class SpiTestCase(TestCase):
    method test_spi1 (line 117) | def test_spi1(self):
    method _test_spi2 (line 124) | def _test_spi2(self):
    method _test_spi3 (line 131) | def _test_spi3(self):
  class SpiGpioTestCase (line 146) | class SpiGpioTestCase(TestCase):
    method setUpClass (line 163) | def setUpClass(cls):
    method setUp (line 167) | def setUp(self):
    method tearDown (line 173) | def tearDown(self):
    method test_ac_to_ad (line 177) | def test_ac_to_ad(self):
    method test_ad_to_ac (line 198) | def test_ad_to_ac(self):
  class SpiUnalignedTestCase (line 220) | class SpiUnalignedTestCase(TestCase):
    method setUpClass (line 229) | def setUpClass(cls):
    method setUp (line 233) | def setUp(self):
    method tearDown (line 238) | def tearDown(self):
    method test_invalid_write (line 242) | def test_invalid_write(self):
    method test_bit_write (line 246) | def test_bit_write(self):
    method test_bytebit_write (line 251) | def test_bytebit_write(self):
    method test_invalid_read (line 256) | def test_invalid_read(self):
    method test_bit_read (line 260) | def test_bit_read(self):
    method test_bytebit_read (line 272) | def test_bytebit_read(self):
    method test_invalid_duplex (line 283) | def test_invalid_duplex(self):
    method test_bit_duplex (line 294) | def test_bit_duplex(self):
    method test_bytebit_duplex (line 303) | def test_bytebit_duplex(self):
  class SpiCsForceTestCase (line 314) | class SpiCsForceTestCase(TestCase):
    method setUpClass (line 322) | def setUpClass(cls):
    method setUp (line 326) | def setUp(self):
    method tearDown (line 331) | def tearDown(self):
    method test_cs_default_pulse (line 335) | def test_cs_default_pulse(self):
    method test_cs_long_pulse (line 339) | def test_cs_long_pulse(self):
    method test_cs_manual_pulse (line 343) | def test_cs_manual_pulse(self):
    method test_cs_pulse_write (line 352) | def test_cs_pulse_write(self):
    method test_cs_default_pulse_rev_clock (line 356) | def test_cs_default_pulse_rev_clock(self):
  function suite (line 364) | def suite():
  function main (line 376) | def main():

FILE: pyftdi/tests/toolsimport.py
  class ToolsTestCase (line 19) | class ToolsTestCase(TestCase):
    method setUpClass (line 29) | def setUpClass(cls):
    method test_ftconf (line 33) | def test_ftconf(self):
    method test_i2cscan (line 39) | def test_i2cscan(self):
    method test_pyterm (line 45) | def test_pyterm(self):
    method test_ftdi_urls (line 51) | def test_ftdi_urls(self):
  function suite (line 58) | def suite():
  function main (line 64) | def main():

FILE: pyftdi/tests/uart.py
  class FtdiTestCase (line 37) | class FtdiTestCase(TestCase):
    method setUpClass (line 42) | def setUpClass(cls):
    method setUp (line 46) | def setUp(self):
  class UartTestCase (line 51) | class UartTestCase(FtdiTestCase):
    method setUpClass (line 69) | def setUpClass(cls):
    method test_uart_cross_talk_sp (line 74) | def test_uart_cross_talk_sp(self):
    method test_uart_cross_talk_mp (line 111) | def test_uart_cross_talk_mp(self):
    method test_uart_loopback (line 136) | def test_uart_loopback(self):
    method test2_uart_cross_talk_speed (line 159) | def test2_uart_cross_talk_speed(self):
    method test_loopback_talk_speed (line 193) | def test_loopback_talk_speed(self):
    method _stream_source (line 224) | def _stream_source(cls, port, chunk, size, results):
    method _stream_sink (line 239) | def _stream_sink(cls, port, size, results):
    method _cross_talk_write_then_read (line 272) | def _cross_talk_write_then_read(cls, url, refstream):
    method _cross_talk_read_then_write (line 293) | def _cross_talk_read_then_write(cls, url, refstream):
    method generate_bytes (line 314) | def generate_bytes(cls, count=0):
    method build_next_url (line 319) | def build_next_url(cls, url):
  class BaudrateTestCase (line 325) | class BaudrateTestCase(FtdiTestCase):
    method test (line 335) | def test(self):
  function suite (line 344) | def suite():
  function main (line 350) | def main():

FILE: pyftdi/tracer.py
  class FtdiMpsseTracer (line 21) | class FtdiMpsseTracer:
    method __init__ (line 36) | def __init__(self, version):
    method send (line 40) | def send(self, iface: int, buf: Union[bytes, bytearray]) -> None:
    method receive (line 43) | def receive(self, iface: int, buf: Union[bytes, bytearray]) -> None:
    method _get_engine (line 46) | def _get_engine(self, iface: int):
  class FtdiMpsseEngine (line 58) | class FtdiMpsseEngine:
    method __init__ (line 69) | def __init__(self, iface: int):
    method send (line 82) | def send(self, buf: Union[bytes, bytearray]) -> None:
    method receive (line 121) | def receive(self, buf: Union[bytes, bytearray]) -> None:
    method _build_commands (line 149) | def _build_commands(cls):
    method _cmd_enable_clk_div5 (line 170) | def _cmd_enable_clk_div5(self):
    method _cmd_disable_clk_div5 (line 176) | def _cmd_disable_clk_div5(self):
    method _cmd_set_tck_divisor (line 182) | def _cmd_set_tck_divisor(self):
    method _cmd_loopback_end (line 192) | def _cmd_loopback_end(self):
    method _cmd_enable_clk_adaptive (line 197) | def _cmd_enable_clk_adaptive(self):
    method _cmd_disable_clk_adaptive (line 202) | def _cmd_disable_clk_adaptive(self):
    method _cmd_enable_clk_3phase (line 207) | def _cmd_enable_clk_3phase(self):
    method _cmd_disable_clk_3phase (line 212) | def _cmd_disable_clk_3phase(self):
    method _cmd_drive_zero (line 217) | def _cmd_drive_zero(self):
    method _cmd_send_immediate (line 226) | def _cmd_send_immediate(self):
    method _cmd_get_bits_low (line 231) | def _cmd_get_bits_low(self):
    method _cmd_get_bits_high (line 236) | def _cmd_get_bits_high(self):
    method _cmd_set_bits_low (line 241) | def _cmd_set_bits_low(self):
    method _cmd_set_bits_high (line 250) | def _cmd_set_bits_high(self):
    method _cmd_write_bytes_pve_msb (line 259) | def _cmd_write_bytes_pve_msb(self):
    method _cmd_write_bytes_nve_msb (line 262) | def _cmd_write_bytes_nve_msb(self):
    method _cmd_write_bytes_pve_lsb (line 265) | def _cmd_write_bytes_pve_lsb(self):
    method _cmd_write_bytes_nve_lsb (line 268) | def _cmd_write_bytes_nve_lsb(self):
    method _cmd_read_bytes_pve_msb (line 271) | def _cmd_read_bytes_pve_msb(self):
    method _resp_read_bytes_pve_msb (line 274) | def _resp_read_bytes_pve_msb(self):
    method _cmd_read_bytes_nve_msb (line 277) | def _cmd_read_bytes_nve_msb(self):
    method _resp_read_bytes_nve_msb (line 280) | def _resp_read_bytes_nve_msb(self):
    method _cmd_read_bytes_pve_lsb (line 283) | def _cmd_read_bytes_pve_lsb(self):
    method _resp_read_bytes_pve_lsb (line 286) | def _resp_read_bytes_pve_lsb(self):
    method _cmd_read_bytes_nve_lsb (line 289) | def _cmd_read_bytes_nve_lsb(self):
    method _resp_read_bytes_nve_lsb (line 292) | def _resp_read_bytes_nve_lsb(self):
    method _cmd_rw_bytes_nve_pve_msb (line 295) | def _cmd_rw_bytes_nve_pve_msb(self):
    method _resp_rw_bytes_nve_pve_msb (line 299) | def _resp_rw_bytes_nve_pve_msb(self):
    method _cmd_rw_bytes_pve_nve_msb (line 302) | def _cmd_rw_bytes_pve_nve_msb(self):
    method _resp_rw_bytes_pve_nve_msb (line 306) | def _resp_rw_bytes_pve_nve_msb(self):
    method _cmd_write_bits_pve_msb (line 309) | def _cmd_write_bits_pve_msb(self):
    method _cmd_write_bits_nve_msb (line 312) | def _cmd_write_bits_nve_msb(self):
    method _cmd_write_bits_pve_lsb (line 315) | def _cmd_write_bits_pve_lsb(self):
    method _cmd_write_bits_nve_lsb (line 318) | def _cmd_write_bits_nve_lsb(self):
    method _cmd_read_bits_pve_msb (line 321) | def _cmd_read_bits_pve_msb(self):
    method _resp_read_bits_pve_msb (line 324) | def _resp_read_bits_pve_msb(self):
    method _cmd_read_bits_nve_msb (line 327) | def _cmd_read_bits_nve_msb(self):
    method _resp_read_bits_nve_msb (line 330) | def _resp_read_bits_nve_msb(self):
    method _cmd_read_bits_pve_lsb (line 333) | def _cmd_read_bits_pve_lsb(self):
    method _resp_read_bits_pve_lsb (line 336) | def _resp_read_bits_pve_lsb(self):
    method _cmd_read_bits_nve_lsb (line 339) | def _cmd_read_bits_nve_lsb(self):
    method _resp_read_bits_nve_lsb (line 342) | def _resp_read_bits_nve_lsb(self):
    method _cmd_rw_bits_nve_pve_msb (line 345) | def _cmd_rw_bits_nve_pve_msb(self):
    method _resp_rw_bits_nve_pve_msb (line 349) | def _resp_rw_bits_nve_pve_msb(self):
    method _cmd_rw_bits_pve_nve_msb (line 352) | def _cmd_rw_bits_pve_nve_msb(self):
    method _resp_rw_bits_pve_nve_msb (line 356) | def _resp_rw_bits_pve_nve_msb(self):
    method _resp_get_bits_low (line 359) | def _resp_get_bits_low(self):
    method _resp_get_bits_high (line 368) | def _resp_get_bits_high(self):
    method _decode_output_mpsse_bytes (line 377) | def _decode_output_mpsse_bytes(self, caller, expect_rx=False):
    method _decode_output_mpsse_bits (line 393) | def _decode_output_mpsse_bits(self, caller, expect_rx=False):
    method _decode_input_mpsse_byte_request (line 407) | def _decode_input_mpsse_byte_request(self):
    method _decode_input_mpsse_bit_request (line 415) | def _decode_input_mpsse_bit_request(self):
    method _decode_input_mpsse_bytes (line 423) | def _decode_input_mpsse_bytes(self, caller):
    method _decode_input_mpsse_bits (line 441) | def _decode_input_mpsse_bits(self, caller):
    method bit2str (line 460) | def bit2str(cls, value: int, count: int, msb: bool, hiz: str = '_') ->...
    method bm2str (line 467) | def bm2str(cls, value: int, mask: int, hiz: str = '_') -> str:
    method bitfmt (line 473) | def bitfmt(cls, value, width):

FILE: pyftdi/usbtools.py
  class UsbToolsError (line 59) | class UsbToolsError(Exception):
  class UsbTools (line 63) | class UsbTools:
    method find_all (line 79) | def find_all(cls, vps: Sequence[Tuple[int, int]],
    method flush_cache (line 107) | def flush_cache(cls, ):
    method get_device (line 122) | def get_device(cls, devdesc: UsbDeviceDescriptor) -> UsbDevice:
    method release_device (line 200) | def release_device(cls, usb_dev: UsbDevice):
    method release_all_devices (line 221) | def release_all_devices(cls, devclass: Optional[Type] = None) -> int:
    method list_devices (line 242) | def list_devices(cls, urlstr: str,
    method parse_url (line 266) | def parse_url(cls, urlstr: str, scheme: str,
    method enumerate_candidates (line 338) | def enumerate_candidates(cls, urlparts: SplitResult,
    method show_devices (line 423) | def show_devices(cls, scheme: str,
    method build_dev_strings (line 451) | def build_dev_strings(cls, scheme: str,
    method get_string (line 526) | def get_string(cls, device: UsbDevice, stridx: int) -> str:
    method find_backend (line 551) | def find_backend(cls) -> IBackend:
    method _find_devices (line 562) | def _find_devices(cls, vendor: int, product: int,
    method _get_backend_device (line 626) | def _get_backend_device(cls, device: UsbDevice) -> Any:
    method _load_backend (line 642) | def _load_backend(cls) -> IBackend:

FILE: setup.py
  function read (line 53) | def read(*parts):
  function read_desc (line 62) | def read_desc(*parts):
  function find_meta (line 73) | def find_meta(meta):
  class BuildPy (line 83) | class BuildPy(build_py):
    method byte_compile (line 100) | def byte_compile(self, files):
  class CheckStyle (line 118) | class CheckStyle(Command):
    method initialize_options (line 124) | def initialize_options(self):
    method finalize_options (line 127) | def finalize_options(self):
    method run (line 130) | def run(self):
  function main (line 156) | def main():