SYMBOL INDEX (763 symbols across 49 files)

FILE: examples/coroutine.py
  function my_exit_handler (line 17) | async def my_exit_handler(bindkey: bytes):
  function my_main_function (line 49) | def my_main_function(device, *coroutines):

FILE: examples/ftdi-echo.py
  function send_hello (line 14) | async def send_hello():
  function uppercasize (line 26) | def uppercasize(data):

FILE: examples/hackrf-info.py
  class HackRF (line 12) | class HackRF(USBDevice):
    class DefaultConfiguration (line 28) | class DefaultConfiguration(USBConfiguration):
      class DefaultInterface (line 29) | class DefaultInterface(USBInterface):
    method handle_control_request_14 (line 40) | def handle_control_request_14(self, request):
    method handle_get_version_request (line 61) | def handle_get_version_request(self, request):
    method handle_get_serial_request (line 73) | def handle_get_serial_request(self, request):

FILE: examples/imperative.py
  class ImperativeDevice (line 22) | class ImperativeDevice(USBDevice):
    method __init__ (line 24) | def __init__(self):
    method handle_my_request (line 51) | def handle_my_request(self, request):
    method handle_data_received (line 58) | def handle_data_received(self, endpoint, data):

FILE: examples/mass-storage.py
  function hello (line 30) | async def hello():

FILE: examples/minimal.py
  class MyDevice (line 13) | class MyDevice(USBDevice):
    class MyConfiguration (line 20) | class MyConfiguration(USBConfiguration):
      class MyInterface (line 22) | class MyInterface(USBInterface):
        class MyInEndpoint (line 24) | class MyInEndpoint(USBEndpoint):
          method handle_data_requested (line 29) | def handle_data_requested(self: USBEndpoint):
        class MyOutEndpoint (line 33) | class MyOutEndpoint(USBEndpoint):
          method handle_data_received (line 38) | def handle_data_received(self: USBEndpoint, data):
    method my_in_vendor_request_handler (line 43) | def my_in_vendor_request_handler(self: USBDevice, request: USBControlR...
    method my_out_vendor_request_handler (line 49) | def my_out_vendor_request_handler(self: USBDevice, request: USBControl...

FILE: examples/rubber-ducky.py
  function type_letters (line 16) | async def type_letters():

FILE: examples/template.py
  class TemplateDevice (line 15) | class TemplateDevice(USBDevice):
    class TemplateConfiguration (line 75) | class TemplateConfiguration(USBConfiguration):
      class TemplateInterface (line 107) | class TemplateInterface(USBInterface):
        class TemplateInEndpoint (line 132) | class TemplateInEndpoint(USBEndpoint):
          method handle_data_requested (line 164) | def handle_data_requested(self):
        class TemplateOutEndpoint (line 174) | class TemplateOutEndpoint(USBEndpoint):
          method handle_data_received (line 186) | def handle_data_received(self, data):
    method handle_data_received (line 194) | def handle_data_received(self, endpoint, data):
    method handle_my_request (line 220) | def handle_my_request(self, request):
    method handle_another_request (line 242) | def handle_another_request(self, request):

FILE: examples/test_minimal.py
  function main (line 3) | def main():

FILE: facedancer/backends/MAXUSBApp.py
  class MAXUSBApp (line 12) | class MAXUSBApp(FacedancerApp, FacedancerBackend):
    method bytes_as_hex (line 60) | def bytes_as_hex(b, delim=" "):
    method send_on_endpoint (line 65) | def send_on_endpoint(self, ep_num, data, blocking=False):
    method read_from_endpoint (line 93) | def read_from_endpoint(self, ep_num):
    method stall_endpoint (line 110) | def stall_endpoint(self, ep_number, direction=0):
    method stall_ep0 (line 132) | def stall_ep0(self, direction=0):
    method get_version (line 136) | def get_version(self):
    method connect (line 140) | def connect(self, usb_device, max_packet_size_ep0=64, device_speed=None):
    method disconnect (line 154) | def disconnect(self):
    method clear_irq_bit (line 162) | def clear_irq_bit(self, reg, bit):
    method service_irqs (line 166) | def service_irqs(self):
    method set_address (line 214) | def set_address(self, address, defer=False):
    method configured (line 227) | def configured(self, configuration):

FILE: facedancer/backends/base.py
  class FacedancerBackend (line 5) | class FacedancerBackend:
    method __init__ (line 6) | def __init__(self, device: USBDevice=None, verbose: int=0, quirks: Lis...
    method appropriate_for_environment (line 19) | def appropriate_for_environment(cls, backend_name: str) -> bool:
    method get_version (line 30) | def get_version(self):
    method connect (line 37) | def connect(self, usb_device: USBDevice, max_packet_size_ep0: int=64, ...
    method disconnect (line 50) | def disconnect(self):
    method reset (line 55) | def reset(self):
    method set_address (line 62) | def set_address(self, address: int, defer: bool=False):
    method configured (line 75) | def configured(self, configuration: USBConfiguration):
    method read_from_endpoint (line 86) | def read_from_endpoint(self, endpoint_number: int) -> bytes:
    method send_on_control_endpoint (line 96) | def send_on_control_endpoint(self, endpoint_number: int, in_request: U...
    method send_on_endpoint (line 111) | def send_on_endpoint(self, endpoint_number: int, data: bytes, blocking...
    method ack_status_stage (line 123) | def ack_status_stage(self, direction: USBDirection=USBDirection.OUT, e...
    method stall_endpoint (line 138) | def stall_endpoint(self, endpoint_number:int, direction: USBDirection=...
    method clear_halt (line 148) | def clear_halt(self, endpoint_number:int, direction: USBDirection):
    method service_irqs (line 160) | def service_irqs(self):
    method validate_configuration (line 168) | def validate_configuration(self, configuration: USBConfiguration):

FILE: facedancer/backends/goodfet.py
  class GoodfetMaxUSBApp (line 11) | class GoodfetMaxUSBApp(MAXUSBApp):
    method appropriate_for_environment (line 17) | def appropriate_for_environment(cls, backend_name):
    method __init__ (line 41) | def __init__(self, device=None, verbose=0, quirks=None):
    method init_commands (line 61) | def init_commands(self):
    method enable (line 67) | def enable(self):
    method ack_status_stage (line 75) | def ack_status_stage(self, blocking=False):
    method read_register (line 82) | def read_register(self, reg_num, ack=False):
    method write_register (line 100) | def write_register(self, reg_num, value, ack=False):
    method read_bytes (line 113) | def read_bytes(self, reg, n):
    method write_bytes (line 128) | def write_bytes(self, reg, data):
  class Facedancer (line 141) | class Facedancer:
    method __init__ (line 142) | def __init__(self, serialport, verbose=0):
    method halt (line 150) | def halt(self):
    method reset (line 154) | def reset(self):
    method read (line 166) | def read(self, n):
    method readcmd (line 180) | def readcmd(self):
    method write (line 205) | def write(self, b):
    method writecmd (line 213) | def writecmd(self, c):
  class FacedancerCommand (line 221) | class FacedancerCommand:
    method __init__ (line 222) | def __init__(self, app=None, verb=None, data=None):
    method __str__ (line 227) | def __str__(self):
    method long_string (line 236) | def long_string(self):
    method as_bytestring (line 249) | def as_bytestring(self):
  class GoodFETMonitorApp (line 262) | class GoodFETMonitorApp(FacedancerApp):
    method read_byte (line 266) | def read_byte(self, addr):
    method get_infostring (line 275) | def get_infostring(self):
    method get_clocking (line 278) | def get_clocking(self):
    method print_info (line 281) | def print_info(self):
    method list_apps (line 288) | def list_apps(self):
    method echo (line 302) | def echo(self, s):
    method announce_connected (line 312) | def announce_connected(self):
  function GoodFETSerialPort (line 318) | def GoodFETSerialPort(**kwargs):

FILE: facedancer/backends/greatdancer.py
  class GreatDancerApp (line 16) | class GreatDancerApp(FacedancerApp, FacedancerBackend):
    method appropriate_for_environment (line 48) | def appropriate_for_environment(cls, backend_name):
    method __init__ (line 72) | def __init__(self, device=None, verbose=0, quirks=None):
    method init_commands (line 123) | def init_commands(self):
    method get_version (line 130) | def get_version(self):
    method ack_status_stage (line 139) | def ack_status_stage(self, direction=HOST_TO_DEVICE, endpoint_number=0...
    method _generate_endpoint_config_arguments (line 164) | def _generate_endpoint_config_arguments(self, config):
    method connect (line 189) | def connect(self, usb_device, max_packet_size_ep0=64, device_speed=Dev...
    method disconnect (line 218) | def disconnect(self):
    method _wait_until_ready_to_send (line 225) | def _wait_until_ready_to_send(self, ep_num):
    method send_on_endpoint (line 241) | def send_on_endpoint(self, ep_num, data, blocking=True):
    method read_from_endpoint (line 263) | def read_from_endpoint(self, ep_num):
    method _endpoint_address (line 283) | def _endpoint_address(ep_num, direction):
    method stall_endpoint (line 294) | def stall_endpoint(self, ep_num, direction=0):
    method stall_ep0 (line 309) | def stall_ep0(self, direction=0):
    method set_address (line 316) | def set_address(self, address, defer=False):
    method _decode_usb_register (line 331) | def _decode_usb_register(transfer_result):
    method _fetch_irq_status (line 345) | def _fetch_irq_status(self):
    method _fetch_setup_status (line 355) | def _fetch_setup_status(self):
    method _handle_setup_events (line 365) | def _handle_setup_events(self):
    method _handle_setup_event_on_endpoint (line 384) | def _handle_setup_event_on_endpoint(self, endpoint_number):
    method _fetch_transfer_status (line 422) | def _fetch_transfer_status(self):
    method _transfer_is_complete (line 432) | def _transfer_is_complete(self, endpoint_number, direction):
    method _handle_transfer_events (line 455) | def _handle_transfer_events(self):
    method _finish_primed_read_on_endpoint (line 499) | def _finish_primed_read_on_endpoint(self, endpoint_number):
    method _clean_up_transfers_for_endpoint (line 512) | def _clean_up_transfers_for_endpoint(self, endpoint_number, direction):
    method _is_control_endpoint (line 531) | def _is_control_endpoint(self, endpoint_number):
    method _handle_transfer_complete_on_endpoint (line 540) | def _handle_transfer_complete_on_endpoint(self, endpoint_number, direc...
    method _fetch_transfer_readiness (line 590) | def _fetch_transfer_readiness(self):
    method _fetch_endpoint_nak_status (line 598) | def _fetch_endpoint_nak_status(self):
    method _prime_out_endpoint (line 606) | def _prime_out_endpoint(self, endpoint_number):
    method _handle_transfer_readiness (line 616) | def _handle_transfer_readiness(self):
    method _is_ready_for_priming (line 651) | def _is_ready_for_priming(self, ep_num, direction):
    method _has_issued_nak (line 673) | def _has_issued_nak(cls, ep_nak, ep_num, direction):
    method _bus_reset (line 693) | def _bus_reset(self):
    method reset (line 706) | def reset(self):
    method _handle_nak_events (line 714) | def _handle_nak_events(self):
    method _configure_endpoints (line 742) | def _configure_endpoints(self, configuration):
    method configured (line 758) | def configured(self, configuration):
    method service_irqs (line 776) | def service_irqs(self):

FILE: facedancer/backends/greathost.py
  class GreatDancerHostApp (line 18) | class GreatDancerHostApp(FacedancerUSBHost):
    method appropriate_for_environment (line 90) | def appropriate_for_environment(cls, backend_name):
    method __init__ (line 114) | def __init__(self, verbose=0, quirks=[], autoconnect=True, device=None):
    method connect (line 136) | def connect(self, device_speed=None):
    method bus_reset (line 143) | def bus_reset(self, delay=0.500):
    method _decode_usb_register (line 161) | def _decode_usb_register(transfer_result):
    method _fetch_status_register (line 174) | def _fetch_status_register(self, register_number):
    method _port_status (line 183) | def _port_status(self):
    method _get_read_status (line 188) | def _get_read_status(self):
    method _get_write_status (line 193) | def _get_write_status(self):
    method device_is_connected (line 198) | def device_is_connected(self):
    method port_is_enabled (line 204) | def port_is_enabled(self):
    method port_is_powered (line 210) | def port_is_powered(self):
    method current_device_speed (line 216) | def current_device_speed(self, as_string=False):
    method current_line_state (line 238) | def current_line_state(self, as_string=False):
    method set_up_endpoint (line 256) | def set_up_endpoint(self, endpoint_address_or_object, endpoint_type=No...
    method initialize_control_endpoint (line 320) | def initialize_control_endpoint(self, device_address=None, device_spee...
    method send_on_endpoint (line 337) | def send_on_endpoint(self, endpoint_number, data, is_setup=False,
    method read_from_endpoint (line 382) | def read_from_endpoint(self, endpoint_number, expected_read_size=64, d...

FILE: facedancer/backends/hydradancer.py
  class HydradancerEvent (line 26) | class HydradancerEvent:
    method from_bytes (line 37) | def from_bytes(data : bytes):
    method __repr__ (line 40) | def __repr__(self):
  class HydradancerHostApp (line 44) | class HydradancerHostApp(FacedancerApp, FacedancerBackend):
    method __init__ (line 60) | def __init__(self, device: USBDevice=None, verbose: int=0, quirks: Lis...
    method appropriate_for_environment (line 86) | def appropriate_for_environment(cls, backend_name: str) -> bool:
    method get_version (line 104) | def get_version(self):
    method connect (line 110) | def connect(self, usb_device: USBDevice, max_packet_size_ep0: int=64, ...
    method disconnect (line 134) | def disconnect(self):
    method reset (line 144) | def reset(self):
    method set_address (line 150) | def set_address(self, address: int, defer: bool=False):
    method configured (line 163) | def configured(self, configuration: USBConfiguration):
    method read_from_endpoint (line 198) | def read_from_endpoint(self, endpoint_number: int) -> bytes:
    method send_on_endpoint (line 207) | def send_on_endpoint(self, endpoint_number: int, data: bytes, blocking...
    method ack_status_stage (line 242) | def ack_status_stage(self, direction: USBDirection=USBDirection.OUT, e...
    method stall_endpoint (line 266) | def stall_endpoint(self, endpoint_number:int, direction: USBDirection=...
    method clear_halt (line 278) | def clear_halt(self, endpoint_number:int, direction: USBDirection):
    method service_irqs (line 288) | def service_irqs(self):
    method handle_bus_reset (line 307) | def handle_bus_reset(self):
    method handle_data_endpoints (line 316) | def handle_data_endpoints(self):
    method handle_control_request (line 344) | def handle_control_request(self):
  class HydradancerBoardFatalError (line 387) | class HydradancerBoardFatalError(Exception):
  class HydradancerBoard (line 391) | class HydradancerBoard():
    method reinit (line 436) | def reinit(self, keep_ep0:bool = False):
    method __init__ (line 456) | def __init__(self):
    method connect (line 544) | def connect(self):
    method disconnect (line 555) | def disconnect(self):
    method wait_board_ready (line 569) | def wait_board_ready(self):
    method set_endpoint_mapping (line 612) | def set_endpoint_mapping(self, ep_num):
    method set_usb2_speed (line 638) | def set_usb2_speed(self, device_speed: DeviceSpeed=DeviceSpeed.FULL):
    method clear_halt (line 650) | def clear_halt(self, endpoint_number:int, direction: USBDirection):
    method set_address (line 658) | def set_address(self, address, defer=False):
    method stall_endpoint (line 670) | def stall_endpoint(self, ep_num, direction=0):
    method send (line 690) | def send(self, ep_num, data):
    method read (line 705) | def read(self, ep_num, blocking=False):
    method configure (line 726) | def configure(self, endpoint_numbers):
    method fetch_events (line 746) | def fetch_events(self):
    method in_buffer_empty (line 787) | def in_buffer_empty(self, ep_num):
    method nak_on_endpoint (line 793) | def nak_on_endpoint(self, ep_num):
    method out_buffer_available (line 799) | def out_buffer_available(self, ep_num):
    method control_buffer_available (line 805) | def control_buffer_available(self):

FILE: facedancer/backends/libusbhost.py
  class LibUSBHostApp (line 15) | class LibUSBHostApp(FacedancerUSBHost):
    method appropriate_for_environment (line 23) | def appropriate_for_environment(cls, backend_name):
    method __init__ (line 45) | def __init__(self, verbose=0, quirks=[], index=0, **kwargs):
    method connect (line 81) | def connect(self, device_speed=None):
    method bus_reset (line 88) | def bus_reset(self, delay=0):
    method current_device_speed (line 105) | def current_device_speed(self, as_string=False):
    method current_line_state (line 115) | def current_line_state(self, as_string=False):
    method device_is_connected (line 124) | def device_is_connected(self):
    method port_is_enabled (line 129) | def port_is_enabled(self):
    method port_is_powered (line 134) | def port_is_powered(self):
    method set_up_endpoint (line 139) | def set_up_endpoint(self, endpoint_address_or_object, endpoint_type=No...
    method initialize_control_endpoint (line 169) | def initialize_control_endpoint(self, device_address=None, device_spee...
    method send_on_endpoint (line 176) | def send_on_endpoint(self, endpoint_number, data, is_setup=False,
    method read_from_endpoint (line 194) | def read_from_endpoint(self, endpoint_number, expected_read_size=64, d...
    method control_request_in (line 210) | def control_request_in(self, request_type, recipient, request, value=0...
    method control_request_out (line 230) | def control_request_out(self, request_type, recipient, request, value=...

FILE: facedancer/backends/moondancer.py
  class QuirkFlag (line 23) | class QuirkFlag(enum.IntFlag):
  class InterruptEvent (line 28) | class InterruptEvent:
    method __init__ (line 34) | def __init__(self, data: Tuple[int, int]):
    method __eq__ (line 58) | def __eq__(self, rhs):
    method __repr__ (line 61) | def __repr__(self):
  class MoondancerApp (line 77) | class MoondancerApp(FacedancerApp, FacedancerBackend):
    method __init__ (line 87) | def __init__(self, device: USBDevice=None, verbose: int=0, quirks: Lis...
    method appropriate_for_environment (line 147) | def appropriate_for_environment(cls, backend_name: str) -> bool:
    method get_version (line 174) | def get_version(self):
    method connect (line 183) | def connect(self, usb_device: USBDevice, max_packet_size_ep0: int=64, ...
    method disconnect (line 216) | def disconnect(self):
    method reset (line 228) | def reset(self):
    method set_address (line 238) | def set_address(self, address: int, defer: bool=False):
    method configured (line 253) | def configured(self, configuration: USBConfiguration):
    method read_from_endpoint (line 298) | def read_from_endpoint(self, endpoint_number: int) -> bytes:
    method send_on_control_endpoint (line 320) | def send_on_control_endpoint(self, endpoint_number: int, in_request: U...
    method send_on_endpoint (line 337) | def send_on_endpoint(self, endpoint_number: int, data: bytes, blocking...
    method ack_status_stage (line 354) | def ack_status_stage(self, direction: USBDirection=USBDirection.OUT, e...
    method stall_endpoint (line 386) | def stall_endpoint(self, endpoint_number:int, direction: USBDirection=...
    method clear_halt (line 409) | def clear_halt(self, endpoint_number: int, direction: USBDirection):
    method service_irqs (line 424) | def service_irqs(self):
    method handle_bus_reset (line 467) | def handle_bus_reset(self):
    method handle_receive_control (line 479) | def handle_receive_control(self, endpoint_number: int):
    method handle_receive_control_packet (line 527) | def handle_receive_control_packet(self, endpoint_number: int):
    method handle_receive_packet (line 576) | def handle_receive_packet(self, endpoint_number: int):
    method handle_send_complete (line 606) | def handle_send_complete(self, endpoint_number: int):
    method handle_ep_in_nak_status (line 611) | def handle_ep_in_nak_status(self, nak_status: int):

FILE: facedancer/backends/raspdancer.py
  class RaspdancerMaxUSBApp (line 21) | class RaspdancerMaxUSBApp(MAXUSBApp):
    method appropriate_for_environment (line 26) | def appropriate_for_environment(cls, backend_name):
    method __init__ (line 49) | def __init__(self, device=None, verbose=0, quirks=None):
    method init_commands (line 68) | def init_commands(self):
    method enable (line 71) | def enable(self):
    method ack_status_stage (line 78) | def ack_status_stage(self, blocking=False):
    method read_register (line 85) | def read_register(self, reg_num, ack=False):
    method write_register (line 101) | def write_register(self, reg_num, value, ack=False):
    method read_bytes (line 113) | def read_bytes(self, reg, n):
    method write_bytes (line 125) | def write_bytes(self, reg, data):
  class Raspdancer (line 134) | class Raspdancer(object):
    method __init__ (line 140) | def __init__(self, verbose=0):
    method reset (line 159) | def reset(self):
    method set_up_comms (line 168) | def set_up_comms(self):
    method transfer (line 180) | def transfer(self, data):

FILE: facedancer/classes/__init__.py
  class USBDeviceClass (line 9) | class USBDeviceClass(IntEnum):

FILE: facedancer/classes/hid/descriptor.py
  function _hid_item_generator (line 19) | def _hid_item_generator(constant) -> Tuple[int]:
  function _io_item_generator (line 46) | def _io_item_generator(type_constant) -> Tuple[int]:
  class HIDCollection (line 124) | class HIDCollection(IntEnum):
  class HIDReportDescriptor (line 136) | class HIDReportDescriptor(USBDescriptor):
    method __call__ (line 146) | def __call__(self, index=0):

FILE: facedancer/classes/hid/keyboard.py
  class KeyboardModifiers (line 149) | class KeyboardModifiers(IntFlag):
  class KeyboardKeys (line 160) | class KeyboardKeys(IntEnum):
    method get_scancode_for_ascii (line 336) | def get_scancode_for_ascii(cls, letter_or_code):

FILE: facedancer/classes/hid/usage.py
  class HIDUsagePage (line 10) | class HIDUsagePage(IntEnum):
  class HIDGenericDesktopUsage (line 37) | class HIDGenericDesktopUsage(IntEnum):

FILE: facedancer/configuration.py
  class USBConfiguration (line 21) | class USBConfiguration(USBDescribable, AutoInstantiable, USBRequestHandl...
    method from_binary_descriptor (line 51) | def from_binary_descriptor(cls, data, strings={}):
    method __post_init__ (line 106) | def __post_init__(self):
    method attributes (line 116) | def attributes(self):
    method get_device (line 133) | def get_device(self):
    method add_interface (line 138) | def add_interface(self, interface: USBInterface):
    method get_endpoint (line 157) | def get_endpoint(self, number: int, direction: USBDirection) -> USBEnd...
    method handle_data_received (line 180) | def handle_data_received(self, endpoint: USBEndpoint, data: bytes):
    method handle_data_requested (line 202) | def handle_data_requested(self, endpoint: USBEndpoint):
    method handle_buffer_empty (line 222) | def handle_buffer_empty(self, endpoint: USBEndpoint):
    method get_interfaces (line 243) | def get_interfaces(self) -> Iterable[USBInterface]:
    method get_descriptor (line 248) | def get_descriptor(self) -> bytes:
    method get_identifier (line 280) | def get_identifier(self) -> int:
    method _request_handlers (line 288) | def _request_handlers(self) -> Iterable[callable]:
    method _get_subordinate_handlers (line 291) | def _get_subordinate_handlers(self) -> Iterable[USBInterface]:
    method generate_code (line 295) | def generate_code(self, name=None, indent=0):

FILE: facedancer/core.py
  function FacedancerUSBApp (line 12) | def FacedancerUSBApp(verbose=0, quirks=None):
  class FacedancerApp (line 25) | class FacedancerApp:
    method autodetect (line 30) | def autodetect(cls, verbose=0, quirks=None):
    method _find_appropriate_subclass (line 62) | def _find_appropriate_subclass(cls, backend_name):
    method appropriate_for_environment (line 83) | def appropriate_for_environment(cls, backend_name=None):
    method __init__ (line 97) | def __init__(self, device, verbose=0):
    method init_commands (line 106) | def init_commands(self):
    method enable (line 109) | def enable(self):
  function FacedancerUSBHostApp (line 113) | def FacedancerUSBHostApp(verbose=0, quirks=None):
  class FacedancerUSBHost (line 125) | class FacedancerUSBHost:
    method autodetect (line 164) | def autodetect(cls, verbose=0, quirks=None):
    method _find_appropriate_subclass (line 198) | def _find_appropriate_subclass(cls, backend_name):
    method appropriate_for_environment (line 221) | def appropriate_for_environment(cls, backend_name=None):
    method _build_request_type (line 236) | def _build_request_type(cls, is_in, req_type, recipient):
    method _build_setup_request (line 259) | def _build_setup_request(cls, is_in, request_type, recipient, request,...
    method control_request_in (line 281) | def control_request_in(self, request_type, recipient, request, value=0...
    method control_request_out (line 327) | def control_request_out(self, request_type, recipient, request, value=...
    method initialize_device (line 354) | def initialize_device(self, apply_configuration=0, assign_address=0):
    method get_descriptor (line 398) | def get_descriptor(self, descriptor_type, descriptor_index,
    method get_device_descriptor (line 408) | def get_device_descriptor(self, max_length=18):
    method read_ep0_max_packet_size (line 417) | def read_ep0_max_packet_size(self):
    method get_configuration_descriptor (line 423) | def get_configuration_descriptor(self, index=0, include_subordinates=T...
    method set_address (line 446) | def set_address(self, device_address):
    method set_configuration (line 461) | def set_configuration(self, index):
    method apply_configuration (line 475) | def apply_configuration(self, index, set_configuration=True):
    method handle_events (line 500) | def handle_events(self):
  class FacedancerBasicScheduler (line 504) | class FacedancerBasicScheduler(object):
    method __init__ (line 512) | def __init__(self):
    method add_task (line 517) | def add_task(self, callback):
    method run (line 527) | def run(self):
    method stop (line 538) | def stop(self):

FILE: facedancer/descriptor.py
  class USBDescribable (line 16) | class USBDescribable(metaclass=DescribableMeta):
    method handles_binary_descriptor (line 25) | def handles_binary_descriptor(cls, data):
    method from_binary_descriptor (line 35) | def from_binary_descriptor(cls, data, strings={}):
  class USBDescriptor (line 49) | class USBDescriptor(USBDescribable, AutoInstantiable):
    method __post_init__ (line 67) | def __post_init__(self):
    method __call__ (line 72) | def __call__(self, index=0):
    method get_identifier (line 76) | def get_identifier(self):
    method from_binary_descriptor (line 80) | def from_binary_descriptor(cls, data, strings={}):
    method generate_code (line 83) | def generate_code(self, name=None, indent=0):
  class USBClassDescriptor (line 123) | class USBClassDescriptor(USBDescriptor):
    method __init_subclass__ (line 128) | def __init_subclass__(cls, **kwargs):
  class USBStringDescriptor (line 136) | class USBStringDescriptor(USBDescriptor):
    method from_string (line 145) | def from_string(cls, string, *, index=None):
  class StringRef (line 154) | class StringRef:
    method __init__ (line 157) | def __init__(self, index: int = None, string : str = None):
    method field (line 165) | def field(cls, **kwargs):
    method lookup (line 171) | def lookup(cls, strings: Dict[int, str], index: int):
    method ensure (line 182) | def ensure(cls, value):
    method generate_code (line 199) | def generate_code(self):
  class StringDescriptorManager (line 211) | class StringDescriptorManager:
    method __init__ (line 214) | def __init__(self):
    method add_string (line 224) | def add_string(self, string, index=None):
    method get_index (line 252) | def get_index(self, string):
    method __getitem__ (line 274) | def __getitem__(self, index):
  class USBDescriptorTypeNumber (line 283) | class USBDescriptorTypeNumber(IntEnum):
  function include_in_config (line 296) | def include_in_config(cls):
  function requestable (line 301) | def requestable(type_number, number):

FILE: facedancer/device.py
  class USBBaseDevice (line 38) | class USBBaseDevice(USBDescribable, USBRequestHandler):
    method from_binary_descriptor (line 95) | def from_binary_descriptor(cls, data, strings={}):
    method __post_init__ (line 138) | def __post_init__(self):
    method add_configuration (line 177) | def add_configuration(self, configuration: USBConfiguration):
    method add_descriptor (line 183) | def add_descriptor(self, descriptor: USBDescriptor):
    method connect (line 208) | def connect(self, device_speed: DeviceSpeed=DeviceSpeed.FULL):
    method disconnect (line 220) | def disconnect(self):
    method run (line 225) | async def run(self):
    method run_with (line 243) | def run_with(self, *coroutines: Iterable[Coroutine]):
    method emulate (line 255) | def emulate(self, *coroutines: Iterable[Coroutine]):
    method stall (line 278) | def stall(self, *, endpoint_number: int = 0, direction: USBDirection =...
    method clear_halt (line 291) | def clear_halt(self, endpoint_number: int, direction: USBDirection):
    method control_send (line 301) | def control_send(self, endpoint_number: int, in_request: USBControlReq...
    method send (line 316) | def send(self, endpoint_number: int, data: bytes, *, blocking: bool = ...
    method _send_in_packets (line 334) | def _send_in_packets(self, endpoint_number: int, data: bytes, *,
    method get_endpoint (line 365) | def get_endpoint(self, endpoint_number: int, direction: USBDirection) ...
    method create_request (line 389) | def create_request(self, raw_data: bytes) -> USBControlRequest:
    method handle_nak (line 398) | def handle_nak(self, ep_num: int):
    method handle_buffer_available (line 411) | def handle_buffer_available(self, ep_num):
    method handle_data_available (line 422) | def handle_data_available(self, ep_num, data):
    method handle_bus_reset (line 439) | def handle_bus_reset(self):
    method handle_request (line 450) | def handle_request(self, request: USBControlRequest):
    method handle_data_received (line 474) | def handle_data_received(self, endpoint: USBEndpoint, data: bytes):
    method handle_unexpected_data_received (line 498) | def handle_unexpected_data_received(self, endpoint_number: int, data: ...
    method handle_data_requested (line 512) | def handle_data_requested(self, endpoint: USBEndpoint):
    method handle_unexpected_data_requested (line 535) | def handle_unexpected_data_requested(self, endpoint_number: int):
    method handle_buffer_empty (line 548) | def handle_buffer_empty(self, endpoint: USBEndpoint):
    method _request_handlers (line 567) | def _request_handlers(self) -> Iterable[callable]:
    method _get_subordinate_handlers (line 571) | def _get_subordinate_handlers(self) -> Iterable[callable]:
    method _add_request_suggestion (line 580) | def _add_request_suggestion(self, request: USBControlRequest):
    method _print_suggested_requests (line 602) | def _print_suggested_requests(self):
    method print_suggested_additions (line 711) | def print_suggested_additions(self):
    method set_address (line 735) | def set_address(self, address: int, defer: bool = False):
    method get_descriptor (line 749) | def get_descriptor(self) -> bytes:
    method get_configuration_descriptor (line 775) | def get_configuration_descriptor(self, index: int) -> bytes:
    method handle_get_supported_languages_descriptor (line 783) | def handle_get_supported_languages_descriptor(self) -> bytes:
    method get_string_descriptor (line 800) | def get_string_descriptor(self, index:int) -> bytes:
    method handle_generic_get_descriptor_request (line 809) | def handle_generic_get_descriptor_request(
  class USBDevice (line 843) | class USBDevice(USBBaseDevice):
    method handle_get_status_request (line 872) | def handle_get_status_request(self, request):
    method handle_clear_feature_request (line 883) | def handle_clear_feature_request(self, request):
    method handle_set_feature_request (line 891) | def handle_set_feature_request(self, request):
    method handle_set_address_request (line 899) | def handle_set_address_request(self, request):
    method handle_get_descriptor_request (line 907) | def handle_get_descriptor_request(self, request):
    method handle_set_descriptor_request (line 917) | def handle_set_descriptor_request(self, request):
    method handle_get_configuration_request (line 925) | def handle_get_configuration_request(self, request):
    method handle_set_configuration_request (line 941) | def handle_set_configuration_request(self, request):
    method handle_synch_frame_request (line 976) | def handle_synch_frame_request(self, request):
    method generate_code (line 982) | def generate_code(self, name="Device"):

FILE: facedancer/devices/__init__.py
  function default_main (line 14) | def default_main(device_or_type, *coroutines):

FILE: facedancer/devices/ftdi.py
  class FTDIFlowControl (line 23) | class FTDIFlowControl(IntFlag):
  class FTDIDevice (line 32) | class FTDIDevice(USBDevice):
    class _Configuration (line 55) | class _Configuration(USBConfiguration):
      class _Interface (line 58) | class _Interface(USBInterface):
        class _OutEndpoint (line 65) | class _OutEndpoint(USBEndpoint):
        class _InEndpoint (line 70) | class _InEndpoint(USBEndpoint):
    method __post_init__ (line 76) | def __post_init__(self):
    method reset_ftdi (line 83) | def reset_ftdi(self):
    method handle_reset_request (line 110) | def handle_reset_request(self, request):
    method handle_modem_ctrl_request (line 118) | def handle_modem_ctrl_request(self, req):
    method handle_set_flow_ctrl_request (line 141) | def handle_set_flow_ctrl_request(self, request):
    method handle_set_baud_rate_request (line 159) | def handle_set_baud_rate_request(self, request):
    method handle_set_data_request (line 183) | def handle_set_data_request(self, request):
    method handle_get_modem_status_request (line 189) | def handle_get_modem_status_request(self, request):
    method handle_set_event_char_request (line 203) | def handle_set_event_char_request(self, request):
    method handle_set_error_char_request (line 209) | def handle_set_error_char_request(self, request):
    method handle_set_latency_timer_request (line 215) | def handle_set_latency_timer_request(self, request):
    method handle_get_latency_timer_request (line 221) | def handle_get_latency_timer_request(self, request):
    method handle_read_eeprom_request (line 228) | def handle_read_eeprom_request(self, request):
    method handle_data_received (line 250) | def handle_data_received(self, endpoint, data):
    method wait_for_host (line 259) | async def wait_for_host(self):
    method handle_serial_data_received (line 267) | def handle_serial_data_received(self, data):
    method transmit (line 275) | def transmit(self, data: Union[str, bytes], *, blocking: bool = False,...
    method _transmit_packet (line 303) | def _transmit_packet(self, data: bytes, *, blocking: bool = False):

FILE: facedancer/devices/keyboard.py
  class USBKeyboardDevice (line 23) | class USBKeyboardDevice(USBDevice):
    class KeyboardConfiguration (line 30) | class KeyboardConfiguration(USBConfiguration):
      class KeyboardInterface (line 34) | class KeyboardInterface(USBInterface):
        class KeyEventEndpoint (line 41) | class KeyEventEndpoint(USBEndpoint):
        class HIDDescriptor (line 53) | class HIDDescriptor(USBDescriptor):
        class ReportDescriptor (line 60) | class ReportDescriptor(HIDReportDescriptor):
        method handle_get_interface_request (line 112) | def handle_get_interface_request(self, request):
    method __post_init__ (line 117) | def __post_init__(self):
    method _generate_hid_report (line 125) | def _generate_hid_report(self) -> bytes:
    method handle_data_requested (line 136) | def handle_data_requested(self, endpoint: USBEndpoint):
    method key_down (line 147) | def key_down(self, code: KeyboardKeys):
    method key_up (line 152) | def key_up(self, code: KeyboardKeys):
    method modifier_down (line 157) | def modifier_down(self, code: KeyboardModifiers):
    method modifier_up (line 163) | def modifier_up(self, code: KeyboardModifiers):
    method type_scancode (line 169) | async def type_scancode(self, code: KeyboardKeys, duration: float = 0....
    method type_scancodes (line 189) | async def type_scancodes(self, *codes: Iterable[KeyboardKeys], duratio...
    method type_letter (line 200) | async def type_letter(self, letter: str, duration: float = 0.1, modifi...
    method type_letters (line 214) | async def type_letters(self, *letters: Iterable[str], duration:float =...
    method type_string (line 225) | async def type_string(self, to_type: str, *, duration:float = 0.1, mod...
    method all_keys_up (line 242) | def all_keys_up(self, *, include_modifiers: bool = True):
    method all_modifiers_up (line 254) | def all_modifiers_up(self):

FILE: facedancer/devices/umass/disk_image.py
  class DiskImage (line 6) | class DiskImage:
    method close (line 14) | def close(self):
    method get_sector_size (line 18) | def get_sector_size(self):
    method get_sector_count (line 21) | def get_sector_count(self):
    method get_data (line 25) | def get_data(self, address, length):
    method get_sector_data (line 39) | def get_sector_data(self, address):
    method put_data (line 44) | def put_data(self, address, data):
    method put_sector_data (line 56) | def put_sector_data(self, address, data):
  class FAT32DiskImage (line 61) | class FAT32DiskImage(DiskImage):
    method __init__ (line 76) | def __init__(self, size = 1024 * 1024 * 256, verbose=0):
    method _register_sector_handler (line 84) | def _register_sector_handler(self, sector_or_lambda, name, handler=None):
    method _initialize_sector_handlers (line 98) | def _initialize_sector_handlers(self):
    method handle_mbr_read (line 109) | def handle_mbr_read(self, address):
    method handle_bpb_read (line 124) | def handle_bpb_read(self, address):
    method handle_fsinfo_read (line 171) | def handle_fsinfo_read(self, address):
    method _generate_directory_entry (line 188) | def _generate_directory_entry(self, filename, file_size, cluster_numbe...
    method _short_filename_checksum (line 210) | def _short_filename_checksum(self, short_filename):
    method _is_valid_83_char (line 225) | def _is_valid_83_char(self, c):
    method _is_valid_83_name (line 238) | def _is_valid_83_name(self, long_filename):
    method _short_filename_from_long (line 248) | def _short_filename_from_long(self, long_filename):
    method _generate_long_directory_entries (line 266) | def _generate_long_directory_entries(self, long_filename, short_filena...
    method handle_root_dir_read (line 312) | def handle_root_dir_read(self, address):
    method _generate_fat_partition_entry (line 323) | def _generate_fat_partition_entry(self):
    method _sectors_per_cluster (line 342) | def _sectors_per_cluster(self):
    method handle_fat_read (line 350) | def handle_fat_read(self, address):
    method handle_unhandled_sector (line 362) | def handle_unhandled_sector(self, address):
    method get_sector_count (line 373) | def get_sector_count(self):
    method get_partition_sectors (line 380) | def get_partition_sectors(self):
    method _find_sector_handler (line 389) | def _find_sector_handler(self, address):
    method get_sector_data (line 410) | def get_sector_data(self, address):
  class RawDiskImage (line 444) | class RawDiskImage(DiskImage):
    method __init__ (line 449) | def __init__(self, filename, block_size, verbose=0):
    method close (line 460) | def close(self):
    method get_sector_count (line 464) | def get_sector_count(self):
    method get_sector_data (line 467) | def get_sector_data(self, address):
    method put_data (line 485) | def put_data(self, address, data):
    method put_sector_data (line 493) | def put_sector_data(self, address, data):

FILE: facedancer/devices/umass/umass.py
  class USBMassStorageDevice (line 29) | class USBMassStorageDevice(USBDevice):
    class _Configuration (line 32) | class _Configuration(USBConfiguration):
      class _Interface (line 35) | class _Interface(USBInterface):
        class _OutEndpoint (line 42) | class _OutEndpoint(USBEndpoint):
        class _InEndpoint (line 48) | class _InEndpoint(USBEndpoint):
    method __init__ (line 54) | def __init__(self, disk_image,
    method connect (line 84) | def connect(self):
    method disconnect (line 91) | def disconnect(self):
    method handle_data_received (line 98) | def handle_data_received(self, endpoint, data):
    method handle_get_max_lun_request (line 112) | def handle_get_max_lun_request(self, request):
    method handle_bulk_only_mass_storage_reset_request (line 117) | def handle_bulk_only_mass_storage_reset_request(self, request):
    method wait_for_host (line 121) | async def wait_for_host(self):
  function bytes_as_hex (line 129) | def bytes_as_hex(b, delim=" "):
  class ScsiCommandHandler (line 132) | class ScsiCommandHandler:
    method __init__ (line 139) | def __init__(self, device, disk_image, verbose=0, vendor="GoodFET "):
    method handle_data_received (line 154) | def handle_data_received(self, data):
    method handle_scsi_command (line 186) | def handle_scsi_command(self, cbw):
    method handle_unknown_command (line 216) | def handle_unknown_command(self, cbw):
    method handle_ignored_event (line 232) | def handle_ignored_event(self, cbw):
    method handle_sense (line 241) | def handle_sense(self, cbw):
    method handle_inquiry (line 249) | def handle_inquiry(self, cbw):
    method handle_mode_sense_6 (line 278) | def handle_mode_sense_6(self, cbw):
    method handle_mode_sense_10 (line 289) | def handle_mode_sense_10(self, cbw):
    method handle_service_action_in (line 300) | def handle_service_action_in(self, cbw):
    method handle_get_format_capacity (line 310) | def handle_get_format_capacity(self, cbw):
    method handle_get_read_capacity (line 320) | def handle_get_read_capacity(self, cbw):
    method handle_get_read_capacity_16 (line 335) | def handle_get_read_capacity_16(self, cbw):
    method handle_read (line 352) | def handle_read(self, cbw):
    method handle_read_16 (line 376) | def handle_read_16(self, cbw):
    method handle_write (line 406) | def handle_write(self, cbw):
    method handle_write_16 (line 429) | def handle_write_16(self, cbw):
    method continue_write (line 458) | def continue_write(self, cbw, data):
    method _register_scsi_commands (line 476) | def _register_scsi_commands(self):
    method _register_scsi_command (line 495) | def _register_scsi_command(self, number, name, handler=None):
  class CommandBlockWrapper (line 507) | class CommandBlockWrapper:
    method __init__ (line 508) | def __init__(self, bytestring):
    method __str__ (line 520) | def __str__(self):

FILE: facedancer/endpoint.py
  class USBEndpoint (line 26) | class USBEndpoint(USBDescribable, AutoInstantiable, USBRequestHandler):
    method from_binary_descriptor (line 69) | def from_binary_descriptor(cls, data, strings={}):
    method __post_init__ (line 96) | def __post_init__(self):
    method address_for_number (line 110) | def address_for_number(endpoint_number: int, direction: USBDirection) ...
    method get_device (line 116) | def get_device(self):
    method send (line 121) | def send(self, data: bytes, *, blocking: bool = False):
    method handle_data_received (line 137) | def handle_data_received(self, data: bytes):
    method handle_data_requested (line 147) | def handle_data_requested(self):
    method handle_buffer_empty (line 151) | def handle_buffer_empty(self):
    method handle_clear_feature_request (line 157) | def handle_clear_feature_request(self, request):
    method address (line 168) | def address(self):
    method get_address (line 173) | def get_address(self):
    method attributes (line 179) | def attributes(self):
    method add_descriptor (line 186) | def add_descriptor(self, descriptor: USBDescriptor):
    method get_descriptor (line 217) | def get_descriptor(self) -> bytes:
    method get_identifier (line 240) | def get_identifier(self) -> int:
    method matches_identifier (line 243) | def matches_identifier(self, other:int) -> bool:
    method _request_handlers (line 253) | def _request_handlers(self) -> Iterable[callable]:
    method __str__ (line 260) | def __str__(self):
    method generate_code (line 269) | def generate_code(self, name=None, indent=0):

FILE: facedancer/errors.py
  class DeviceNotFoundError (line 5) | class DeviceNotFoundError(IOError):
  class EndEmulation (line 9) | class EndEmulation(Exception):

FILE: facedancer/filters/base.py
  class USBProxyFilter (line 6) | class USBProxyFilter:
    method filter_control_in_setup (line 11) | def filter_control_in_setup(self, request, stalled):
    method filter_control_in (line 29) | def filter_control_in(self, request, data, stalled):
    method filter_control_out (line 49) | def filter_control_out(self, request, data):
    method handle_out_request_stall (line 66) | def handle_out_request_stall(self, request, data, stalled):
    method filter_in_token (line 79) | def filter_in_token(self, ep_num):
    method filter_in (line 95) | def filter_in(self, ep_num, data):
    method filter_out (line 112) | def filter_out(self, ep_num, data):
    method handle_out_stall (line 127) | def handle_out_stall(self, ep_num, data, stalled):

FILE: facedancer/filters/hid.py
  class HIDReportType (line 32) | class HIDReportType(IntEnum):
  class USBProxyHIDFilter (line 38) | class USBProxyHIDFilter(USBProxyFilter):
    method __init__ (line 45) | def __init__(self, device: USBBaseDevice, verbose=1):
    method filter_control_in (line 50) | def filter_control_in(self, req: USBControlRequest | None, data, stall...
    method _log_desc (line 61) | def _log_desc(self, req, data):
    method _log_in (line 88) | def _log_in(self, req, data):
    method filter_control_out (line 97) | def filter_control_out(self, req, data):
    method _log_out (line 103) | def _log_out(self, req, data):
    method filter_in (line 115) | def filter_in(self, ep_num, data):
    method _find_interface (line 121) | def _find_interface(self, ep_num):
    method _log_ep_in (line 130) | def _log_ep_in(self, iface, num, data):
    method _report (line 134) | def _report(self, iface: int, kind: str, data: bytes):
  function dump (line 148) | def dump(raw: bytes):

FILE: facedancer/filters/logging.py
  class USBProxyPrettyPrintFilter (line 12) | class USBProxyPrettyPrintFilter(USBProxyFilter):
    method __init__ (line 17) | def __init__(self, verbose=4, decoration=''):
    method filter_control_in (line 26) | def filter_control_in(self, req, data, stalled):
    method filter_control_out (line 48) | def filter_control_out(self, req, data):
    method handle_out_request_stall (line 68) | def handle_out_request_stall(self, req, data, stalled):
    method filter_in (line 81) | def filter_in(self, ep_num, data):
    method filter_out (line 91) | def filter_out(self, ep_num, data):
    method timestamp (line 102) | def timestamp(self):
    method _magic_decode (line 106) | def _magic_decode(self, data):
    method _pretty_print_data (line 114) | def _pretty_print_data(self, data, direction_marker, decoration='', is...

FILE: facedancer/filters/standard.py
  class USBProxySetupFilters (line 14) | class USBProxySetupFilters(USBProxyFilter):
    method __init__ (line 27) | def __init__(self, device, verbose=0):
    method filter_control_in (line 32) | def filter_control_in(self, req, data, stalled):
    method filter_control_out (line 67) | def filter_control_out(self, req, data):

FILE: facedancer/interface.py
  class USBInterface (line 28) | class USBInterface(USBDescribable, AutoInstantiable, USBRequestHandler):
    method from_binary_descriptor (line 63) | def from_binary_descriptor(cls, data, strings={}):
    method __post_init__ (line 81) | def __post_init__(self):
    method get_device (line 99) | def get_device(self):
    method add_endpoint (line 104) | def add_endpoint(self, endpoint: USBEndpoint):
    method get_endpoint (line 120) | def get_endpoint(self, endpoint_number: int, direction: USBDirection) ...
    method has_endpoint (line 134) | def has_endpoint(self, endpoint_number: int, direction: USBDirection) ...
    method add_descriptor (line 144) | def add_descriptor(self, descriptor: USBDescriptor):
    method handle_data_received (line 179) | def handle_data_received(self, endpoint: USBEndpoint, data: bytes):
    method handle_data_requested (line 198) | def handle_data_requested(self, endpoint: USBEndpoint):
    method handle_buffer_empty (line 215) | def handle_buffer_empty(self, endpoint: USBEndpoint):
    method get_endpoints (line 233) | def get_endpoints(self):
    method handle_get_descriptor_request (line 244) | def handle_get_descriptor_request(self, request):
    method get_descriptor (line 253) | def get_descriptor(self) -> bytes:
    method handle_set_interface_request (line 296) | def handle_set_interface_request(self, request: USBControlRequest):
    method handle_get_interface_request (line 323) | def handle_get_interface_request(self, request):
    method get_identifier (line 345) | def get_identifier(self) -> (int, int):
    method matches_identifier (line 353) | def matches_identifier(self, other: int) -> bool:
    method _request_handlers (line 361) | def _request_handlers(self) -> Iterable[callable]:
    method _get_subordinate_handlers (line 364) | def _get_subordinate_handlers(self) -> Iterable[callable]:
    method generate_code (line 368) | def generate_code(self, name=None, indent=0):

FILE: facedancer/logging.py
  function configure_default_logging (line 12) | def configure_default_logging(level=logging.INFO, logger=logging):
  function _initialize_logging (line 22) | def _initialize_logging():

FILE: facedancer/magic.py
  class DescribableMeta (line 12) | class DescribableMeta(ABCMeta):
    method __new__ (line 14) | def __new__(cls, name, bases, classdict):
  function adjust_defaults (line 26) | def adjust_defaults(cls, **kwargs):
  class AutoInstantiable (line 35) | class AutoInstantiable(metaclass=DescribableMeta):
    method get_identifier (line 39) | def get_identifier(self) -> int:
    method matches_identifier (line 45) | def matches_identifier(self, other: int) -> bool:
  class AutoInstantiator (line 49) | class AutoInstantiator:
    method __init__ (line 56) | def __init__(self, target_type):
    method creates_instance_of (line 59) | def creates_instance_of(self, expected_type):
    method __call__ (line 62) | def __call__(self, parent):
  function use_automatically (line 66) | def use_automatically(cls):
  function _use_inner_classes_automatically (line 96) | def _use_inner_classes_automatically(cls):
  function use_inner_classes_automatically (line 112) | def use_inner_classes_automatically(cls):
  function instantiate_subordinates (line 117) | def instantiate_subordinates(obj, expected_type):

FILE: facedancer/proxy.py
  class USBProxyDevice (line 21) | class USBProxyDevice(USBBaseDevice):
    method __init__ (line 28) | def __init__(self, index=0, quirks=[], scheduler=None, **kwargs):
    method add_filter (line 54) | def add_filter(self, filter_object, head=False):
    method connect (line 64) | def connect(self):
    method configured (line 95) | def configured(self, configuration: USBConfiguration):
    method interface_changed (line 118) | def interface_changed(self, interface_number: int, alternate: int):
    method handle_bus_reset (line 134) | def handle_bus_reset(self):
    method handle_request (line 138) | def handle_request(self, request: USBControlRequest):
    method handle_get_configuration_request (line 149) | def handle_get_configuration_request(self, request):
    method handle_get_descriptor_request (line 153) | def handle_get_descriptor_request(self, request):
    method handle_data_available (line 157) | def handle_data_available(self, ep_num, data):
    method handle_nak (line 181) | def handle_nak(self, ep_num):
    method _ack_status_stage (line 203) | def _ack_status_stage(self, blocking=False):
    method _proxy_in_control_request (line 206) | def _proxy_in_control_request(self, request: USBControlRequest):
    method _proxy_out_control_request (line 255) | def _proxy_out_control_request(self, request: USBControlRequest):
    method _proxy_in_transfer (line 289) | def _proxy_in_transfer(self, endpoint):
  class LibUSB1Device (line 329) | class LibUSB1Device:
    method _get_libusb_context (line 341) | def _get_libusb_context(cls):
    method _destroy_libusb_context (line 353) | def _destroy_libusb_context(cls):
    method open (line 377) | def open(cls, device, detach=True):
    method find (line 407) | def find(cls, idVendor, idProduct, find_all=True):
    method device_speed (line 426) | def device_speed(cls):
    method controlRead (line 431) | def controlRead(cls, request_type, request, value, index, length, time...
    method controlWrite (line 436) | def controlWrite(cls, request_type, request, value, index, data, timeo...
    method read (line 441) | def read(cls, endpoint_number, length, timeout=1000):
    method write (line 450) | def write(cls, endpoint_number, data, timeout=1000):
    method clear_halt (line 456) | def clear_halt(cls, endpoint_number, direction):
  function configure_logging (line 479) | async def configure_logging():

FILE: facedancer/request.py
  function _wrap_with_field_matcher (line 18) | def _wrap_with_field_matcher(func, field_name, field_value, match_index=...
  class ControlRequestHandler (line 60) | class ControlRequestHandler:
    method __init__ (line 68) | def __init__(self, handler_function, execution_condition):
    method __call__ (line 73) | def __call__(self, caller, request):
    method add_condition (line 84) | def add_condition(self, condition):
    method add_field_matcher (line 90) | def add_field_matcher(self, field_name, field_value):
    method __repr__ (line 101) | def __repr__(self):
  function control_request_handler (line 106) | def control_request_handler(condition=lambda _ : True, **kwargs):
  function standard_request_handler (line 133) | def standard_request_handler(**kwargs):
  function vendor_request_handler (line 138) | def vendor_request_handler(**kwargs):
  function class_request_handler (line 143) | def class_request_handler(**kwargs):
  function reserved_request_handler (line 148) | def reserved_request_handler(**kwargs):
  function to_device (line 157) | def to_device(func):
  function to_this_endpoint (line 161) | def to_this_endpoint(func):
  function to_any_endpoint (line 165) | def to_any_endpoint(func):
  function to_this_interface (line 169) | def to_this_interface(func):
  function to_any_interface (line 173) | def to_any_interface(func):
  function to_other (line 177) | def to_other(func):
  function get_request_handler_methods (line 186) | def get_request_handler_methods(cls) -> List[callable]:
  class USBControlRequest (line 202) | class USBControlRequest:
    method from_raw_bytes (line 222) | def from_raw_bytes(cls, raw_bytes: bytes, *, device = None):
    method reply (line 252) | def reply(self, data: bytes):
    method acknowledge (line 257) | def acknowledge(self, *, blocking: bool = False):
    method ack (line 266) | def ack(self, *, blocking: bool = False):
    method stall (line 278) | def stall(self):
    method request (line 294) | def request(self) -> int:
    method request_type (line 299) | def request_type(self) -> int:
    method value_low (line 306) | def value_low(self) -> int:
    method value_high (line 310) | def value_high(self) -> int:
    method index_low (line 314) | def index_low(self) -> int:
    method index_high (line 318) | def index_high(self) -> int:
    method get_direction (line 321) | def get_direction(self) -> USBDirection:
    method get_type (line 324) | def get_type(self) -> USBRequestType:
    method get_recipient (line 327) | def get_recipient(self) -> USBRequestRecipient:
    method raw (line 331) | def raw(self) -> bytes:
    method __str__ (line 345) | def __str__(self):
  class USBRequestHandler (line 364) | class USBRequestHandler(metaclass=ABCMeta):
    method _request_handlers (line 369) | def _request_handlers(self) -> Iterable[callable]:
    method _get_subordinate_handlers (line 373) | def _get_subordinate_handlers(self) -> Iterable[callable]:
    method _call_subordinate_handlers (line 381) | def _call_subordinate_handlers(self, request: USBControlRequest) -> bool:
    method handle_request (line 400) | def handle_request(self, request: USBControlRequest) -> bool:

FILE: facedancer/types.py
  class USBDirection (line 8) | class USBDirection(IntEnum):
    method is_in (line 13) | def is_in(self):
    method is_out (line 16) | def is_out(self):
    method parse (line 20) | def parse(cls, value):
    method from_request_type (line 25) | def from_request_type(cls, request_type_int):
    method from_endpoint_address (line 30) | def from_endpoint_address(cls, address):
    method token (line 34) | def token(self):
    method reverse (line 38) | def reverse(self):
    method to_endpoint_address (line 43) | def to_endpoint_address(self, endpoint_number):
  class USBPIDCategory (line 51) | class USBPIDCategory(IntFlag):
  class USBPacketID (line 63) | class USBPacketID(IntFlag):
    method from_byte (line 96) | def from_byte(cls, byte, skip_checks=False):
    method from_int (line 105) | def from_int(cls, value, skip_checks=True):
    method from_name (line 124) | def from_name(cls, name):
    method parse (line 130) | def parse(cls, value):
    method category (line 145) | def category(self):
    method is_data (line 150) | def is_data(self):
    method is_token (line 155) | def is_token(self):
    method is_handshake (line 160) | def is_handshake(self):
    method is_invalid (line 165) | def is_invalid(self):
    method direction (line 169) | def direction(self):
    method summarize (line 185) | def summarize(self):
  class USBRequestRecipient (line 198) | class USBRequestRecipient(IntEnum):
    method from_integer (line 209) | def from_integer(cls, value):
    method from_request_type (line 221) | def from_request_type(cls, request_type_int):
  class USBRequestType (line 228) | class USBRequestType(IntEnum):
    method from_request_type (line 238) | def from_request_type(cls, request_type_int):
  class USBTransferType (line 248) | class USBTransferType(IntEnum):
  function endpoint_number_from_address (line 255) | def endpoint_number_from_address(number):
  class LanguageIDs (line 258) | class LanguageIDs(IntEnum):
  class DescriptorTypes (line 409) | class DescriptorTypes(IntEnum):
  class USBSynchronizationType (line 422) | class USBSynchronizationType(IntEnum):
  class USBUsageType (line 429) | class USBUsageType(IntEnum):
  class USBStandardRequests (line 435) | class USBStandardRequests(IntEnum):
  class DeviceSpeed (line 452) | class DeviceSpeed(IntEnum):
  class USB (line 470) | class USB:
    method interface_class_to_descriptor_type (line 512) | def interface_class_to_descriptor_type(interface_class):

FILE: test/base.py
  class FacedancerTestCase (line 27) | class FacedancerTestCase(unittest.TestCase):
    method setUpClass (line 32) | def setUpClass(cls):
    method tearDownClass (line 42) | def tearDownClass(cls):
    method bulk_out_transfer (line 49) | def bulk_out_transfer(self, ep, data):
    method bulk_in_transfer (line 59) | def bulk_in_transfer(self, ep, length):
    method control_out_transfer (line 69) | def control_out_transfer(self, data):
    method control_in_transfer (line 83) | def control_in_transfer(self, length):
    method set_in_transfer_length (line 99) | def set_in_transfer_length(self, length):
    method get_last_out_transfer_data (line 112) | def get_last_out_transfer_data(self):
    method reset_device_state (line 125) | def reset_device_state(self):
    method set_interface (line 137) | def set_interface(self, interface_number, alternate):
    method get_interface (line 141) | def get_interface(self, interface_number):

FILE: test/device.py
  class StressTestDevice (line 19) | class StressTestDevice(USBDevice):
    method __post_init__ (line 26) | def __post_init__(self):
    class MyConfiguration (line 31) | class MyConfiguration(USBConfiguration):
      class MyInterface (line 33) | class MyInterface(USBInterface):
        class MyOutEndpoint (line 37) | class MyOutEndpoint(USBEndpoint):
          method handle_data_received (line 42) | def handle_data_received(self: USBEndpoint, data):
        class MyInEndpoint (line 46) | class MyInEndpoint(USBEndpoint):
          method handle_data_requested (line 51) | def handle_data_requested(self: USBEndpoint):
      class MyAlternateInterface (line 56) | class MyAlternateInterface(USBInterface):
        class MyOutEndpoint (line 60) | class MyOutEndpoint(USBEndpoint):
          method handle_data_received (line 65) | def handle_data_received(self: USBEndpoint, data):
        class MyInEndpoint (line 69) | class MyInEndpoint(USBEndpoint):
          method handle_data_requested (line 74) | def handle_data_requested(self: USBEndpoint):
    method out_vendor_request (line 81) | def out_vendor_request(self: USBDevice, request: USBControlRequest):
    method in_vendor_request (line 89) | def in_vendor_request(self: USBDevice, request: USBControlRequest):
    method set_in_transfer_length (line 99) | def set_in_transfer_length(self: USBDevice, request: USBControlRequest):
    method get_last_out_transfer_data (line 107) | def get_last_out_transfer_data(self: USBDevice, request: USBControlReq...
    method reset_device_state (line 114) | def reset_device_state(self: USBDevice, request: USBControlRequest):
  function generate_data (line 123) | def generate_data(length):

FILE: test/test_alternate.py
  class TestAlternate (line 14) | class TestAlternate(FacedancerTestCase):
    method setUp (line 18) | def setUp(self):
    method test_alternate_interfaces (line 23) | def test_alternate_interfaces(self):

FILE: test/test_descriptors.py
  class TestDescriptors (line 71) | class TestDescriptors(unittest.TestCase):
    method test_device_descriptor_reconstruction (line 73) | def test_device_descriptor_reconstruction(self):
    method test_config_descriptor_reconstruction (line 78) | def test_config_descriptor_reconstruction(self):
    method test_code_generation (line 86) | def test_code_generation(self):

FILE: test/test_stress.py
  function test_transfer_length (line 17) | def test_transfer_length():
  class TestStress (line 21) | class TestStress(FacedancerTestCase):
    method setUp (line 26) | def setUp(self):
    method test_stress_test (line 33) | def test_stress_test(self):
  function highly_stressed_edition (line 74) | def highly_stressed_edition():

FILE: test/test_transfers.py
  function test_transfer_length (line 15) | def test_transfer_length():
  class TestTransfers (line 26) | class TestTransfers(FacedancerTestCase):
    method setUp (line 31) | def setUp(self):
    method check_out_transfer (line 41) | def check_out_transfer(self, length, sent_data, bytes_sent):
    method check_in_transfer (line 55) | def check_in_transfer(self, length, received_data):
    method test_bulk_out_transfer (line 68) | def test_bulk_out_transfer(self):
    method test_bulk_in_transfer (line 80) | def test_bulk_in_transfer(self):
    method test_control_out_transfer (line 92) | def test_control_out_transfer(self):
    method test_control_in_transfer (line 104) | def test_control_in_transfer(self):