Mercurial Repositories > eric / file diff

--- a/src/eric7/APIs/MicroPython/circuitpython.api	Wed Sep 28 15:35:06 2022 +0200
+++ b/src/eric7/APIs/MicroPython/circuitpython.api	Wed Sep 28 16:15:56 2022 +0200
@@ -1,691 +1,743 @@
+_bleio.Adapter.connect?4(address: Address, *, timeout: float)
+_bleio.Adapter.erase_bonding?4()
+_bleio.Adapter.start_advertising?4(data: ReadableBuffer, *, scan_response: Optional[ReadableBuffer] = None, connectable: bool = True, anonymous: bool = False, timeout: int = 0, interval: float = 0.1, tx_power: int = 0, directed_to: Optional[Address] = None, )
+_bleio.Adapter.start_scan?4(prefixes: ReadableBuffer = b"", *, buffer_size: int = 512, extended: bool = False, timeout: Optional[float] = None, interval: float = 0.1, window: float = 0.1, minimum_rssi: int = -80, active: bool = True, )
+_bleio.Adapter.stop_advertising?4()
+_bleio.Adapter.stop_scan?4()
+_bleio.Adapter?1(*, uart: busio.UART, rts: digitalio.DigitalInOut, cts: digitalio.DigitalInOut, )
+_bleio.Address?1(address: ReadableBuffer, address_type: int)
+_bleio.Attribute?1()
+_bleio.Characteristic.add_to_service?4(service: Service, uuid: UUID, *, properties: int = 0, read_perm: int = Attribute.OPEN, write_perm: int = Attribute.OPEN, max_length: int = 20, fixed_length: bool = False, initial_value: Optional[ReadableBuffer] = None, user_description: Optional[str] = None, )
+_bleio.Characteristic.set_cccd?4(*, notify: bool = False, indicate: bool = False)
+_bleio.Characteristic?1()
+_bleio.CharacteristicBuffer.deinit?4()
+_bleio.CharacteristicBuffer.read?4(nbytes: Optional[int] = None)
+_bleio.CharacteristicBuffer.readinto?4(buf: WriteableBuffer)
+_bleio.CharacteristicBuffer.readline?4()
+_bleio.CharacteristicBuffer.reset_input_buffer?4()
+_bleio.CharacteristicBuffer?1(characteristic: Characteristic, *, timeout: int = 1, buffer_size: int = 64)
+_bleio.Connection.disconnect?4()
+_bleio.Connection.discover_remote_services?4(service_uuids_whitelist: Optional[Iterable[UUID]] = None)
+_bleio.Connection.pair?4(*, bond: bool = True)
+_bleio.Connection?1()
+_bleio.Descriptor.add_to_characteristic?4(characteristic: Characteristic, uuid: UUID, *, read_perm: int = Attribute.OPEN, write_perm: int = Attribute.OPEN, max_length: int = 20, fixed_length: bool = False, initial_value: ReadableBuffer = b"", )
+_bleio.Descriptor?1()
+_bleio.PacketBuffer.deinit?4()
+_bleio.PacketBuffer.readinto?4(buf: WriteableBuffer)
+_bleio.PacketBuffer.write?4(data: ReadableBuffer, *, header: Optional[bytes] = None)
+_bleio.PacketBuffer?1(characteristic: Characteristic, *, buffer_size: int, max_packet_size: Optional[int] = None, )
+_bleio.ScanEntry.matches?4(prefixes: ScanEntry, *, match_all: bool = True)
+_bleio.ScanEntry?1()
+_bleio.ScanResults?1()
+_bleio.Service?1(uuid: UUID, *, secondary: bool = False)
+_bleio.UUID.pack_into?4(buffer: WriteableBuffer, offset: int = 0)
+_bleio.UUID?1(value: Union[int, ReadableBuffer, str])
+_bleio.set_adapter?4(adapter: Optional[_bleio.Adapter])
+_eve._EVE.AlphaFunc?4(func: int, ref: int)
+_eve._EVE.Begin?4(prim: int)
+_eve._EVE.BitmapExtFormat?4(format: int)
+_eve._EVE.BitmapHandle?4(handle: int)
+_eve._EVE.BitmapLayout?4(format: int, linestride: int, height: int)
+_eve._EVE.BitmapLayoutH?4(linestride: int, height: int)
+_eve._EVE.BitmapSize?4(filter: int, wrapx: int, wrapy: int, width: int, height: int)
+_eve._EVE.BitmapSizeH?4(width: int, height: int)
+_eve._EVE.BitmapSource?4(addr: int)
+_eve._EVE.BitmapSwizzle?4(r: int, g: int, b: int, a: int)
+_eve._EVE.BitmapTransformA?4(p: int, v: int)
+_eve._EVE.BitmapTransformB?4(p: int, v: int)
+_eve._EVE.BitmapTransformC?4(v: int)
+_eve._EVE.BitmapTransformD?4(p: int, v: int)
+_eve._EVE.BitmapTransformE?4(p: int, v: int)
+_eve._EVE.BitmapTransformF?4(v: int)
+_eve._EVE.BlendFunc?4(src: int, dst: int)
+_eve._EVE.Call?4(dest: int)
+_eve._EVE.Cell?4(cell: int)
+_eve._EVE.Clear?4(c: int, s: int, t: int)
+_eve._EVE.ClearColorA?4(alpha: int)
+_eve._EVE.ClearColorRGB?4(red: int, green: int, blue: int)
+_eve._EVE.ClearStencil?4(s: int)
+_eve._EVE.ClearTag?4(s: int)
+_eve._EVE.ColorA?4(alpha: int)
+_eve._EVE.ColorMask?4(r: int, g: int, b: int, a: int)
+_eve._EVE.ColorRGB?4(red: int, green: int, blue: int)
+_eve._EVE.Display?4()
+_eve._EVE.End?4()
+_eve._EVE.Jump?4(dest: int)
+_eve._EVE.LineWidth?4(width: float)
+_eve._EVE.Macro?4(m: int)
+_eve._EVE.Nop?4()
+_eve._EVE.PaletteSource?4(addr: int)
+_eve._EVE.PointSize?4(size: float)
+_eve._EVE.RestoreContext?4()
+_eve._EVE.Return?4()
+_eve._EVE.SaveContext?4()
+_eve._EVE.ScissorSize?4(width: int, height: int)
+_eve._EVE.ScissorXY?4(x: int, y: int)
+_eve._EVE.StencilFunc?4(func: int, ref: int, mask: int)
+_eve._EVE.StencilMask?4(mask: int)
+_eve._EVE.StencilOp?4(sfail: int, spass: int)
+_eve._EVE.Tag?4(s: int)
+_eve._EVE.TagMask?4(mask: int)
+_eve._EVE.Vertex2f?4(b: float)
+_eve._EVE.Vertex2ii?4(x: int, y: int, handle: int, cell: int)
+_eve._EVE.VertexFormat?4(frac: int)
+_eve._EVE.VertexTranslateX?4(x: float)
+_eve._EVE.VertexTranslateY?4(y: float)
+_eve._EVE.cc?4(b: ReadableBuffer)
+_eve._EVE.cmd0?4(n: int)
+_eve._EVE.cmd?4(n: int, fmt: str, args: Tuple[str, ...])
+_eve._EVE.flush?4()
+_eve._EVE.register?4(o: object)
+_eve._EVE?2()
+_pew.PewPew?1(buffer: ReadableBuffer, rows: List[digitalio.DigitalInOut], cols: List[digitalio.DigitalInOut], buttons: digitalio.DigitalInOut, )
+_stage.Layer.frame?4(frame: int, rotation: int)
+_stage.Layer.move?4(x: int, y: int)
+_stage.Layer?1(width: int, height: int, graphic: ReadableBuffer, palette: ReadableBuffer, grid: ReadableBuffer, )
+_stage.Text.move?4(x: int, y: int)
+_stage.Text?1(width: int, height: int, font: ReadableBuffer, palette: ReadableBuffer, chars: ReadableBuffer, )
+_stage.render?4(x0: int, y0: int, x1: int, y1: int, layers: List[Layer], buffer: WriteableBuffer, display: displayio.Display, scale: int, background: int, )
+adafruit_bus_device.i2c_device.I2CDevice.readinto?4(buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize)
+adafruit_bus_device.i2c_device.I2CDevice.write?4(buffer: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize)
+adafruit_bus_device.i2c_device.I2CDevice.write_then_readinto?4(out_buffer: ReadableBuffer, in_buffer: WriteableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize, )
+adafruit_bus_device.i2c_device.I2CDevice?1(i2c: busio.I2C, device_address: int, probe: bool = True)
+adafruit_bus_device.spi_device.SPIDevice?1(spi: busio.SPI, chip_select: digitalio.DigitalInOut, *, baudrate: int = 100000, polarity: int = 0, phase: int = 0, extra_clocks: int = 0, )
+adafruit_pixelbuf.PixelBuf.fill?4(color: Union[int, Tuple[int, int, int], Tuple[int, int, int, float]])
+adafruit_pixelbuf.PixelBuf.show?4()
+adafruit_pixelbuf.PixelBuf?1(size: int, *, byteorder: str = "BGR", brightness: float = 0, auto_write: bool = False, header: ReadableBuffer = b"", trailer: ReadableBuffer = b"", )
+aesio.AES.decrypt_into?4(src: ReadableBuffer, dest: WriteableBuffer)
+aesio.AES.encrypt_into?4(src: ReadableBuffer, dest: WriteableBuffer)
+aesio.AES?1(key: ReadableBuffer, mode: int = 0, iv: Optional[ReadableBuffer] = None, segment_size: int = 8, )
+alarm.SleepMemory?1()
+alarm.exit_and_deep_sleep_until_alarms?4(*alarms: circuitpython_typing.Alarm, preserve_dios: Sequence[digitalio.DigitalInOut] = (), )
+alarm.light_sleep_until_alarms?4(*alarms: circuitpython_typing.Alarm, )
+alarm.pin.PinAlarm?1(pin: microcontroller.Pin, value: bool, edge: bool = False, pull: bool = False, )
+alarm.time.TimeAlarm?1(monotonic_time: Optional[float] = None, epoch_time: Optional[int] = None)
+alarm.touch.TouchAlarm?1(*pin: microcontroller.Pin)
+analogbufio.BufferedIn.deinit?4()
+analogbufio.BufferedIn.read?4()
+analogbufio.BufferedIn?1(pin: microcontroller.Pin, buffer: WriteableBuffer, *, sample_rate: int = 500000, )
 analogio.AnalogIn.deinit?4()
-analogio.AnalogIn.reference_voltage?7
-analogio.AnalogIn.value?7
-analogio.AnalogIn?1(pin)
+analogio.AnalogIn?1(pin: microcontroller.Pin)
 analogio.AnalogOut.deinit?4()
-analogio.AnalogOut.value?7
-analogio.AnalogOut?1(pin)
-array.array.append?4(value)
-array.array.extend?4(iterable)
-array.array?1(typecode, iterable=None)
+analogio.AnalogOut?1(pin: microcontroller.Pin)
+atexit.register?4(func: Callable[..., Any], *args: Optional[Any], **kwargs: Optional[Any])
+atexit.unregister?4(func: Callable[..., Any])
 audiobusio.I2SOut.deinit?4()
 audiobusio.I2SOut.pause?4()
-audiobusio.I2SOut.paused?7
-audiobusio.I2SOut.play?4(sample, *, loop=False)
-audiobusio.I2SOut.playing?7
+audiobusio.I2SOut.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
 audiobusio.I2SOut.resume?4()
 audiobusio.I2SOut.stop?4()
-audiobusio.I2SOut?1(bit_clock, word_select, data, *, left_justified)
+audiobusio.I2SOut?1(bit_clock: microcontroller.Pin, word_select: microcontroller.Pin, data: microcontroller.Pin, *, left_justified: bool, )
 audiobusio.PDMIn.deinit?4()
-audiobusio.PDMIn.record?4(destination, destination_length)
-audiobusio.PDMIn.sample_rate?7
-audiobusio.PDMIn?1(clock_pin, data_pin, *, sample_rate=16000, bit_depth=8, mono=True, oversample=64, startup_delay=0.11)
-audiocore.Mixer.deinit?4()
-audiocore.Mixer.play?4(sample, *, voice=0, loop=False)
-audiocore.Mixer.playing?7
-audiocore.Mixer.sample_rate?7
-audiocore.Mixer.stop_voice?4(voice=0)
-audiocore.Mixer?1(channel_count=2, buffer_size=1024)
+audiobusio.PDMIn.record?4(destination: WriteableBuffer, destination_length: int)
+audiobusio.PDMIn?1(clock_pin: microcontroller.Pin, data_pin: microcontroller.Pin, *, sample_rate: int = 16000, bit_depth: int = 8, mono: bool = True, oversample: int = 64, startup_delay: float = 0.11, )
 audiocore.RawSample.deinit?4()
-audiocore.RawSample.sample_rate?7
-audiocore.RawSample?1(buffer, *, channel_count=1, sample_rate=8000)
-audiocore.WaveFile.bits_per_sample?7
-audiocore.WaveFile.channel_count?7
+audiocore.RawSample?1(buffer: ReadableBuffer, *, channel_count: int = 1, sample_rate: int = 8000)
 audiocore.WaveFile.deinit?4()
-audiocore.WaveFile.sample_rate?7
-audiocore.WaveFile?1(file, buffer=None)
+audiocore.WaveFile?1(file: Union[str, typing.BinaryIO], buffer: WriteableBuffer)
 audioio.AudioOut.deinit?4()
 audioio.AudioOut.pause?4()
-audioio.AudioOut.paused?7
-audioio.AudioOut.play?4(sample, *, loop=False)
-audioio.AudioOut.playing?7
+audioio.AudioOut.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
 audioio.AudioOut.resume?4()
 audioio.AudioOut.stop?4()
-audioio.AudioOut?1(left_channel, *, right_channel=None, quiescent_value=0x8000)
+audioio.AudioOut?1(left_channel: microcontroller.Pin, *, right_channel: Optional[microcontroller.Pin] = None, quiescent_value: int = 0x8000, )
+audiomixer.Mixer.deinit?4()
+audiomixer.Mixer.play?4(sample: circuitpython_typing.AudioSample, *, voice: int = 0, loop: bool = False, )
+audiomixer.Mixer.stop_voice?4(voice: int = 0)
+audiomixer.Mixer?1(voice_count: int = 2, buffer_size: int = 1024, channel_count: int = 2, bits_per_sample: int = 16, samples_signed: bool = True, sample_rate: int = 8000, )
+audiomixer.MixerVoice.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
+audiomixer.MixerVoice.stop?4()
+audiomixer.MixerVoice?1()
+audiomp3.MP3Decoder.deinit?4()
+audiomp3.MP3Decoder.open?4(filepath: str)
+audiomp3.MP3Decoder?1(file: Union[str, typing.BinaryIO], buffer: WriteableBuffer)
 audiopwmio.PWMAudioOut.deinit?4()
 audiopwmio.PWMAudioOut.pause?4()
-audiopwmio.PWMAudioOut.paused?7
-audiopwmio.PWMAudioOut.play?4(sample, *, loop=False)
-audiopwmio.PWMAudioOut.playing?7
+audiopwmio.PWMAudioOut.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
 audiopwmio.PWMAudioOut.resume?4()
 audiopwmio.PWMAudioOut.stop?4()
-audiopwmio.PWMAudioOut?1(left_channel, *, right_channel=None, quiescent_value=0x8000)
-binascii.a2b_base64?4(data)
-binascii.b2a_base64?4(data)
-binascii.hexlify?4(data, sep="")
-binascii.unhexlify?4(data)
+audiopwmio.PWMAudioOut?1(left_channel: microcontroller.Pin, *, right_channel: Optional[microcontroller.Pin] = None, quiescent_value: int = 0x8000, )
 bitbangio.I2C.deinit?4()
-bitbangio.I2C.readfrom_into?4(address, buffer, *, start=0, end=None)
+bitbangio.I2C.readfrom_into?4(address: int, buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize, )
 bitbangio.I2C.scan?4()
 bitbangio.I2C.try_lock?4()
 bitbangio.I2C.unlock?4()
-bitbangio.I2C.writeto?4(address, buffer, *, start=0, end=None, stop=True)
-bitbangio.I2C.writeto_then_readfrom?4(address, out_buffer, in_buffer, *, out_start=0, out_end=None, in_start=0, in_end=None)
-bitbangio.I2C?1(scl, sda, *, frequency=400000, timeout)
-bitbangio.OneWire.deinit?4()
-bitbangio.OneWire.read_bit?4()
-bitbangio.OneWire.reset?4()
-bitbangio.OneWire.write_bit?4(value)
-bitbangio.OneWire?1(pin)
-bitbangio.SPI.configure?4(*, baudrate=100000, polarity=0, phase=0, bits=8)
+bitbangio.I2C.writeto?4(address: int, buffer: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize, )
+bitbangio.I2C.writeto_then_readfrom?4(address: int, out_buffer: ReadableBuffer, in_buffer: ReadableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize, )
+bitbangio.I2C?1(scl: microcontroller.Pin, sda: microcontroller.Pin, *, frequency: int = 400000, timeout: int = 255, )
+bitbangio.SPI.configure?4(*, baudrate: int = 100000, polarity: int = 0, phase: int = 0, bits: int = 8, )
 bitbangio.SPI.deinit?4()
-bitbangio.SPI.readinto?4(buf)
+bitbangio.SPI.readinto?4(buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize, write_value: int = 0, )
 bitbangio.SPI.try_lock?4()
 bitbangio.SPI.unlock?4()
-bitbangio.SPI.write?4(buf)
-bitbangio.SPI.write_readinto?4(buffer_out, buffer_in, *, out_start=0, out_end=None, in_start=0, in_end=None)
-bitbangio.SPI?1(clock, MOSI=None, MISO=None)
-bleio.Adapter.address?7
-bleio.Adapter.default_name?7
-bleio.Adapter.enabled?7
-bleio.Address.PUBLIC?7
-bleio.Address.RANDOM_PRIVATE_NON_RESOLVABLE?7
-bleio.Address.RANDOM_PRIVATE_RESOLVABLE?7
-bleio.Address.RANDOM_STATIC?7
-bleio.Address.address_bytes?7
-bleio.Address.type?7
-bleio.Address?1(address, address_type)
-bleio.Attribute.ENCRYPT_NO_MITM?7
-bleio.Attribute.ENCRYPT_WITH_MITM?7
-bleio.Attribute.LESC_ENCRYPT_WITH_MITM?7
-bleio.Attribute.NO_ACCESS?7
-bleio.Attribute.OPEN?7
-bleio.Attribute.SIGNED_NO_MITM?7
-bleio.Attribute.SIGNED_WITH_MITM?7
-bleio.Central.connect?4(address, timeout, *, service_uuids_whitelist=None)
-bleio.Central.connected?7
-bleio.Central.disconnect?4()
-bleio.Central.discover_remote_services?4(service_uuids_whitelist=None)
-bleio.Central?1()
-bleio.Characteristic.BROADCAST?7
-bleio.Characteristic.INDICATE?7
-bleio.Characteristic.NOTIFY?7
-bleio.Characteristic.READ?7
-bleio.Characteristic.WRITE?7
-bleio.Characteristic.WRITE_NO_RESPONSE?7
-bleio.Characteristic.descriptors?7
-bleio.Characteristic.properties?7
-bleio.Characteristic.service?4(read_only)
-bleio.Characteristic.set_cccd?4(*, notify=False, indicate=False)
-bleio.Characteristic.uuid?7
-bleio.Characteristic.value?7
-bleio.Characteristic?1(uuid, *, properties=0, read_perm=Attribute.OPEN, write_perm=Attribute.OPEN, max_length=20, fixed_length=False, descriptors=None)
-bleio.CharacteristicBuffer.deinit?4()
-bleio.CharacteristicBuffer.in_waiting?7
-bleio.CharacteristicBuffer.read?4(nbytes=None)
-bleio.CharacteristicBuffer.readinto?4(buf)
-bleio.CharacteristicBuffer.readline?4()
-bleio.CharacteristicBuffer.reset_input_buffer?4()
-bleio.CharacteristicBuffer?1(characteristic, *, timeout=1, buffer_size=64)
-bleio.Descriptor.characteristic?4(read_only)
-bleio.Descriptor.uuid?7
-bleio.Descriptor.value?7
-bleio.Descriptor?1(uuid, *, read_perm=Attribute.OPEN, write_perm=Attribute.OPEN)
-bleio.Peripheral.connected?4(read_only)
-bleio.Peripheral.disconnect?4()
-bleio.Peripheral.discover_remote_services?4(service_uuids_whitelist=None)
-bleio.Peripheral.name?7
-bleio.Peripheral.pair?4()
-bleio.Peripheral.services?7
-bleio.Peripheral.start_advertising?4(data, *, scan_response=None, connectable=True, interval=1)
-bleio.Peripheral.stop_advertising?4()
-bleio.Peripheral?1(services=(), *, name=None)
-bleio.ScanEntry.address?7
-bleio.ScanEntry.advertisement_bytes?7
-bleio.ScanEntry.rssi?7
-bleio.Scanner.scan?4(timeout, *, interval=0.1, window=0.1)
-bleio.Scanner?1()
-bleio.Service.remotes?7
-bleio.Service.secondary?7
-bleio.Service.uuids?7
-bleio.Service?1(uuid, characteristics, *, secondary=False)
-bleio.UUID.size?7
-bleio.UUID.uuid128?7
-bleio.UUID.uuid16?7
-bleio.UUID?1(value)
-bleio.adapter?7
+bitbangio.SPI.write?4(buf: ReadableBuffer)
+bitbangio.SPI.write_readinto?4(out_buffer: ReadableBuffer, in_buffer: WriteableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize, )
+bitbangio.SPI?1(clock: microcontroller.Pin, MOSI: Optional[microcontroller.Pin] = None, MISO: Optional[microcontroller.Pin] = None, )
+bitmaptools.alphablend?4(dest_bitmap: displayio.Bitmap, source_bitmap_1: displayio.Bitmap, source_bitmap_2: displayio.Bitmap, colorspace: displayio.Colorspace, factor1: float = 0.5, factor2: Optional[float] = None, )
+bitmaptools.arrayblit?4(bitmap: displayio.Bitmap, data: ReadableBuffer, x1: int = 0, y1: int = 0, x2: Optional[int] = None, y2: Optional[int] = None, skip_index: Optional[int] = None, )
+bitmaptools.boundary_fill?4(dest_bitmap: displayio.Bitmap, x: int, y: int, fill_color_value: int, replaced_color_value: int, )
+bitmaptools.dither?4(dest_bitmap: displayio.Bitmap, source_bitmapp: displayio.Bitmap, source_colorspace: displayio.Colorspace, algorithm: DitherAlgorithm = DitherAlgorithm.Atkinson, )
+bitmaptools.draw_line?4(dest_bitmap: displayio.Bitmap, x1: int, y1: int, x2: int, y2: int, value: int)
+bitmaptools.fill_region?4(dest_bitmap: displayio.Bitmap, x1: int, y1: int, x2: int, y2: int, value: int)
+bitmaptools.readinto?4(bitmap: displayio.Bitmap, file: typing.BinaryIO, bits_per_pixel: int, element_size: int = 1, reverse_pixels_in_element: bool = False, swap_bytes_in_element: bool = False, reverse_rows: bool = False, )
+bitmaptools.rotozoom?4(dest_bitmap: displayio.Bitmap, source_bitmap: displayio.Bitmap, *, ox: int, oy: int, dest_clip0: Tuple[int, int], dest_clip1: Tuple[int, int], px: int, py: int, source_clip0: Tuple[int, int], source_clip1: Tuple[int, int], angle: float, scale: float, skip_index: int, )
+bitops.bit_transpose?4(input: ReadableBuffer, output: WriteableBuffer, width: int = 8)
 board.I2C?4()
 board.SPI?4()
 board.UART?4()
-btree.BTree.close?4()
-btree.BTree.flush?4()
-btree.BTree.get?4(key, default=None)
-btree.BTree.items?4(start_key=None, end_key=None, flags=0)
-btree.BTree.keys?4(start_key=None, end_key=None, flags=0)
-btree.BTree.values?4(start_key=None, end_key=None, flags=0)
-btree.DESC?7
-btree.INCL?7
-btree.open?4(stream, *, flags=0, pagesize=0, cachesize=0, minkeypage=0)
 busio.I2C.deinit?4()
-busio.I2C.readfrom_into?4(address, buffer, *, start=0, end=None)
+busio.I2C.readfrom_into?4(address: int, buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize, )
 busio.I2C.scan?4()
 busio.I2C.try_lock?4()
 busio.I2C.unlock?4()
-busio.I2C.writeto?4(address, buffer, *, start=0, end=None, stop=True)
-busio.I2C?1(scl, sda, *, frequency=400000)
-busio.OneWire.deinit?4()
-busio.OneWire.read_bit?4()
-busio.OneWire.reset?4()
-busio.OneWire.write_bit?4(value)
-busio.OneWire?1(pin)
-busio.SPI.configure?4(*, baudrate=100000, polarity=0, phase=0, bits=8)
+busio.I2C.writeto?4(address: int, buffer: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize, )
+busio.I2C.writeto_then_readfrom?4(address: int, out_buffer: ReadableBuffer, in_buffer: WriteableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize, )
+busio.I2C?1(scl: microcontroller.Pin, sda: microcontroller.Pin, *, frequency: int = 100000, timeout: int = 255, )
+busio.SPI.configure?4(*, baudrate: int = 100000, polarity: int = 0, phase: int = 0, bits: int = 8, )
 busio.SPI.deinit?4()
-busio.SPI.frequency?7
-busio.SPI.readinto?4(buffer, *, start=0, end=None, write_value=0)
+busio.SPI.readinto?4(buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize, write_value: int = 0, )
 busio.SPI.try_lock?4()
 busio.SPI.unlock?4()
-busio.SPI.write?4(buffer, *, start=0, end=None)
-busio.SPI.write_readinto?4(buffer_out, buffer_in, *, out_start=0, out_end=None, in_start=0, in_end=None)
-busio.SPI?1(clock, MOSI=None, MISO=None)
-busio.UART.baudrate?7
+busio.SPI.write?4(buffer: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize)
+busio.SPI.write_readinto?4(out_buffer: ReadableBuffer, in_buffer: WriteableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize, )
+busio.SPI?1(clock: microcontroller.Pin, MOSI: Optional[microcontroller.Pin] = None, MISO: Optional[microcontroller.Pin] = None, half_duplex: bool = False, )
 busio.UART.deinit?4()
-busio.UART.in_waiting?7
-busio.UART.read?4(nbytes=None)
-busio.UART.readinto?4(buf)
+busio.UART.read?4(nbytes: Optional[int] = None)
+busio.UART.readinto?4(buf: WriteableBuffer)
 busio.UART.readline?4()
 busio.UART.reset_input_buffer?4()
-busio.UART.write?4(buf)
-busio.UART?1(x, rx, *, baudrate=9600, bits=8, parity=None, stop=1, timeout=1, receiver_buffer_size=64)
-collections.OrderedDict?1(iterableOfKeyValue)
-collections.namedtuple?1(name, fields)
+busio.UART.write?4(buf: ReadableBuffer)
+busio.UART?1(tx: microcontroller.Pin, rx: microcontroller.Pin, *, baudrate: int = 9600, bits: int = 8, parity: Optional[Parity] = None, stop: int = 1, timeout: float = 1, receiver_buffer_size: int = 64, )
+camera.Camera.deinit?4()
+camera.Camera.take_picture?4(buf: WriteableBuffer, format: ImageFormat)
+camera.Camera?1()
+camera.ImageFormat?1()
+canio.CAN.deinit?4()
+canio.CAN.listen?4(matches: Optional[Sequence[Match]] = None, *, timeout: float = 10)
+canio.CAN.restart?4()
+canio.CAN.send?4(message: Union[RemoteTransmissionRequest, Message])
+canio.CAN?1(tx: microcontroller.Pin, rx: microcontroller.Pin, *, baudrate: int = 250000, loopback: bool = False, silent: bool = False, auto_restart: bool = False, )
+canio.Listener.deinit?4()
+canio.Listener.in_waiting?4()
+canio.Listener.receive?4()
+canio.Match?1(id: int, *, mask: Optional[int] = None, extended: bool = False)
+canio.Message?1(id: int, data: bytes, *, extended: bool = False)
+canio.RemoteTransmissionRequest?1(id: int, length: int, *, extended: bool = False)
+countio.Counter.deinit?4()
+countio.Counter.reset?4()
+countio.Counter?1(pin: microcontroller.Pin, *, edge: Edge = Edge.FALL, pull: Optional[digitalio.Pull] = None, )
+countio.Edge?1()
 digitalio.DigitalInOut.deinit?4()
-digitalio.DigitalInOut.direction?7
-digitalio.DigitalInOut.drive_mode?7
-digitalio.DigitalInOut.pull?7
-digitalio.DigitalInOut.switch_to_input?4(pull=None)
-digitalio.DigitalInOut.switch_to_output?4(value=False, drive_mode=DriveMode.PUSH_PULL)
-digitalio.DigitalInOut.value?7
-digitalio.DigitalInOut?1(pin)
-digitalio.DriveMode.OPEN_DRAIN?7
-digitalio.DriveMode.PUSH_PULL?7
-digitalio.Pull.DOWN?7
-digitalio.Pull.UP?7
-displayio.Bitmap.height?7
-displayio.Bitmap.width?7
-displayio.Bitmap?1(width, height, value_count)
-displayio.ColorConverter.convert?4(color)
-displayio.ColorConverter?1()
-displayio.Display.auto_brightness?7
-displayio.Display.brightness?7
-displayio.Display.bus?7
-displayio.Display.height?7
-displayio.Display.refresh_soon?4()
-displayio.Display.show?4(group)
-displayio.Display.wait_for_frame?4()
-displayio.Display.width?7
-displayio.Display?1(display_bus, init_sequence, *, width, height, colstart=0, rowstart=0, rotation=0, color_depth=16, set_column_command=0x2a, set_row_command=0x2b, write_ram_command=0x2c, set_vertical_scroll=0, backlight_pin=None, brightness=1.0, auto_brightness=False, single_byte_bounds=False, data_as_commands=False)
-displayio.FourWire.send?4(command, data)
-displayio.FourWire?1(spi_bus, *, command, chip_select, reset=None)
-displayio.Group.append?4(layer)
-displayio.Group.insert?4(index, layer)
-displayio.Group.pop?4(i=-1)
-displayio.Group.scale?7
-displayio.Group.x?7
-displayio.Group.y?7
-displayio.Group?1(*, max_size=4, scale=1, x=0, y=0)
-displayio.OnDiskBitmap.height?7
-displayio.OnDiskBitmap.width?7
-displayio.OnDiskBitmap?1(file)
-displayio.Palette.make_opaque?4(palette_index)
-displayio.Palette.make_transparent?4(palette_index)
-displayio.Palette?1(color_count)
-displayio.ParallelBus.send?4(command, data)
-displayio.ParallelBus?1(*, data0, command, chip_select, write, read, reset)
-displayio.Shape.set_boundary?4(y, start_x, end_x)
-displayio.Shape?1(width, height, *, mirror_x=False, mirror_y=False)
-displayio.TileGrid.pixel_shader?7
-displayio.TileGrid.x?7
-displayio.TileGrid.y?7
-displayio.TileGrid?1(bitmap, *, pixel_shader, width=1, height=1, tile_width=None, tile_height=None, default_tile=0, x=0, y=0)
+digitalio.DigitalInOut.switch_to_input?4(pull: Optional[Pull] = None)
+digitalio.DigitalInOut.switch_to_output?4(value: bool = False, drive_mode: DriveMode = DriveMode.PUSH_PULL)
+digitalio.DigitalInOut?1(pin: microcontroller.Pin)
+digitalio.Direction?1()
+digitalio.DriveMode?1()
+digitalio.Pull?1()
+displayio.Bitmap.blit?4(x: int, y: int, source_bitmap: Bitmap, *, x1: int, y1: int, x2: int, y2: int, skip_index: int, )
+displayio.Bitmap.dirty?4(x1: int = 0, y1: int = 0, x2: int = -1, y2: int = -1)
+displayio.Bitmap.fill?4(value: int)
+displayio.Bitmap?1(width: int, height: int, value_count: int)
+displayio.ColorConverter.convert?4(color: int)
+displayio.ColorConverter.make_opaque?4(color: int)
+displayio.ColorConverter.make_transparent?4(color: int)
+displayio.ColorConverter?1(*, input_colorspace: Colorspace = Colorspace.RGB888, dither: bool = False)
+displayio.Display.fill_row?4(y: int, buffer: WriteableBuffer)
+displayio.Display.refresh?4(*, target_frames_per_second: Optional[int] = None, minimum_frames_per_second: int = 0, )
+displayio.Display.show?4(group: Group)
+displayio.Display?1(display_bus: _DisplayBus, init_sequence: ReadableBuffer, *, width: int, height: int, colstart: int = 0, rowstart: int = 0, rotation: int = 0, color_depth: int = 16, grayscale: bool = False, pixels_in_byte_share_row: bool = True, bytes_per_cell: int = 1, reverse_pixels_in_byte: bool = False, set_column_command: int = 0x2A, set_row_command: int = 0x2B, write_ram_command: int = 0x2C, backlight_pin: Optional[microcontroller.Pin] = None, brightness_command: Optional[int] = None, brightness: float = 1.0, single_byte_bounds: bool = False, data_as_commands: bool = False, auto_refresh: bool = True, native_frames_per_second: int = 60, backlight_on_high: bool = True, SH1107_addressing: bool = False, )
+displayio.EPaperDisplay.refresh?4()
+displayio.EPaperDisplay.show?4(group: Group)
+displayio.EPaperDisplay.update_refresh_mode?4(start_sequence: ReadableBuffer, seconds_per_frame: float = 180)
+displayio.EPaperDisplay?1(display_bus: _DisplayBus, start_sequence: ReadableBuffer, stop_sequence: ReadableBuffer, *, width: int, height: int, ram_width: int, ram_height: int, colstart: int = 0, rowstart: int = 0, rotation: int = 0, set_column_window_command: Optional[int] = None, set_row_window_command: Optional[int] = None, set_current_column_command: Optional[int] = None, set_current_row_command: Optional[int] = None, write_black_ram_command: int, black_bits_inverted: bool = False, write_color_ram_command: Optional[int] = None, color_bits_inverted: bool = False, highlight_color: int = 0x000000, refresh_display_command: int, refresh_time: float = 40, busy_pin: Optional[microcontroller.Pin] = None, busy_state: bool = True, seconds_per_frame: float = 180, always_toggle_chip_select: bool = False, grayscale: bool = False, two_byte_sequence_length: bool = False, )
+displayio.FourWire.reset?4()
+displayio.FourWire.send?4(command: int, data: ReadableBuffer, *, toggle_every_byte: bool = False)
+displayio.FourWire?1(spi_bus: busio.SPI, *, command: Optional[microcontroller.Pin], chip_select: microcontroller.Pin, reset: Optional[microcontroller.Pin] = None, baudrate: int = 24000000, polarity: int = 0, phase: int = 0, )
+displayio.Group.append?4(layer: Union[
+            vectorio.Circle, vectorio.Rectangle, vectorio.Polygon, Group, TileGrid
+        ], )
+displayio.Group.index?4(layer: Union[
+            vectorio.Circle, vectorio.Rectangle, vectorio.Polygon, Group, TileGrid
+        ], )
+displayio.Group.insert?4(index: int, layer: Union[
+            vectorio.Circle, vectorio.Rectangle, vectorio.Polygon, Group, TileGrid
+        ], )
+displayio.Group.pop?4(i: int = -1)
+displayio.Group.remove?4(layer: Union[
+            vectorio.Circle, vectorio.Rectangle, vectorio.Polygon, Group, TileGrid
+        ], )
+displayio.Group.sort?4(key: function, reverse: bool)
+displayio.Group?1(*, scale: int = 1, x: int = 0, y: int = 0)
+displayio.I2CDisplay.reset?4()
+displayio.I2CDisplay.send?4(command: int, data: ReadableBuffer)
+displayio.I2CDisplay?1(i2c_bus: busio.I2C, *, device_address: int, reset: Optional[microcontroller.Pin] = None, )
+displayio.OnDiskBitmap?1(file: Union[str, typing.BinaryIO])
+displayio.Palette.is_transparent?4(palette_index: int)
+displayio.Palette.make_opaque?4(palette_index: int)
+displayio.Palette.make_transparent?4(palette_index: int)
+displayio.Palette?1(color_count: int)
+displayio.Shape.set_boundary?4(y: int, start_x: int, end_x: int)
+displayio.Shape?1(width: int, height: int, *, mirror_x: bool = False, mirror_y: bool = False)
+displayio.TileGrid.contains?4(touch_tuple: tuple)
+displayio.TileGrid?1(bitmap: Union[Bitmap, OnDiskBitmap, Shape], *, pixel_shader: Union[ColorConverter, Palette], width: int = 1, height: int = 1, tile_width: Optional[int] = None, tile_height: Optional[int] = None, default_tile: int = 0, x: int = 0, y: int = 0, )
+displayio._DisplayBus?8
 displayio.release_displays?4()
-esp.SLEEP_LIGHT?7
-esp.SLEEP_MODEM?7
-esp.SLEEP_NONE?7
-esp.deepsleep?4(time=0)
-esp.flash_erase?4(sector_no)
-esp.flash_id?4()
-esp.flash_read?4(byte_offset, length_or_buffer)
-esp.flash_size?4()
-esp.flash_user_start?4()
-esp.flash_write?4(byte_offset, bytes)
-esp.set_native_code_location?4(start, length)
-esp.sleep_type?4(sleep_type=None)
-fontio.BuiltinFont.bitmap?7
+dotenv.get_key?4(dotenv_path: str, key_to_get: str)
+dotenv.load_dotenv?4()
+dualbank.flash?4(buffer: ReadableBuffer, offset: int = 0)
+dualbank.switch?4()
+esp32_camera.Camera.deinit?4()
+esp32_camera.Camera.reconfigure?4(frame_size: Optional[FrameSize] = None, pixel_format: Optional[PixelFormat] = None, grab_mode: Optional[GrabMode] = None, framebuffer_count: Optional[int] = None, )
+esp32_camera.Camera.take?4(timeout: Optional[float] = 0.25)
+esp32_camera.Camera?1(*, data_pins: List[microcontroller.Pin], pixel_clock_pin: microcontroller.Pin, vsync_pin: microcontroller.Pin, href_pin: microcontroller.Pin, i2c: busio.I2C, external_clock_pin: microcontroller.Pin, external_clock_frequency: int, powerdown_pin: Optional[microcontroller.Pin] = None, reset_pin: Optional[microcontroller.Pin] = None, pixel_format: PixelFormat = PixelFormat.RGB565, frame_size: FrameSize = FrameSize.QQVGA, jpeg_quality: int = 15, framebuffer_count: int = 1, grab_mode: GrabMode = GrabMode.WHEN_EMPTY, )
+espidf.erase_nvs?4()
+espidf.get_reserved_psram?4()
+espidf.get_total_psram?4()
+espidf.heap_caps_get_free_size?4()
+espidf.heap_caps_get_largest_free_block?4()
+espidf.heap_caps_get_total_size?4()
+floppyio.flux_readinto?4(buffer: WriteableBuffer, data: digitalio.DigitalInOut, index: digitalio.DigitalInOut)
+floppyio.mfm_readinto?4(buffer: WriteableBuffer, data: digitalio.DigitalInOut, index: digitalio.DigitalInOut)
 fontio.BuiltinFont.get_bounding_box?4()
-fontio.BuiltinFont.get_glyph?4(codepoint)
-fontio.Glyph?1(bitmap, tile_index, width, height, dx, dy, shift_x, shift_y)
-framebuf.FrameBuffer.blit?4(fbuf, x, y, key=None)
-framebuf.FrameBuffer.fill?4(c)
-framebuf.FrameBuffer.fill_rect?4(x, y, w, h, c)
-framebuf.FrameBuffer.hline?4(x, y, w, c)
-framebuf.FrameBuffer.line?4(x1, y1, x2, y2, c)
-framebuf.FrameBuffer.pixel?4(x, y, c=None)
-framebuf.FrameBuffer.rect?4(x, y, w, h, c)
-framebuf.FrameBuffer.scroll?4(xstep, ystep)
-framebuf.FrameBuffer.text?4(s, x, y, c=None)
-framebuf.FrameBuffer.vline?4(x, y, h, c)
-framebuf.FrameBuffer?1(buffer, width, height, format, stride=None)
-framebuf.GS2_HMSB?7
-framebuf.GS4_HMSB?7
-framebuf.GS8?7
-framebuf.MONO_HLSB?7
-framebuf.MONO_HMSB?7
-framebuf.MONO_VLSB?7
-framebuf.RGB565?7
-frequencyio.FrequencyIn.capture_period?7
+fontio.BuiltinFont.get_glyph?4(codepoint: int)
+fontio.BuiltinFont?1()
+fontio.FontProtocol.get_bounding_box?4()
+fontio.FontProtocol.get_glyph?4(codepoint: int)
+fontio.Glyph?1(bitmap: displayio.Bitmap, tile_index: int, width: int, height: int, dx: int, dy: int, shift_x: int, shift_y: int, )
+framebufferio.FramebufferDisplay.fill_row?4(y: int, buffer: WriteableBuffer)
+framebufferio.FramebufferDisplay.refresh?4(*, target_frames_per_second: int = 60, minimum_frames_per_second: int = 1)
+framebufferio.FramebufferDisplay.show?4(group: displayio.Group)
+framebufferio.FramebufferDisplay?1(framebuffer: circuitpython_typing.FrameBuffer, *, rotation: int = 0, auto_refresh: bool = True, )
 frequencyio.FrequencyIn.clear?4()
 frequencyio.FrequencyIn.deinit?4()
 frequencyio.FrequencyIn.pause?4()
 frequencyio.FrequencyIn.resume?4()
-frequencyio.FrequencyIn?1(pin, capture_period=10)
-gamepad.GamePad.deinit?4()
-gamepad.GamePad.get_pressed?4()
-gamepad.GamePad?1(b1=None, b2=None, b3=None, b4=None, b5=None, b6=None, b7=None, b8=None)
-gamepadshift.GamePadShift.deinit?4()
-gamepadshift.GamePadShift.get_pressed?4()
-gamepadshift.GamePadShift?1(clock, data, latch)
-gc.collect?4()
-gc.disable?4()
-gc.enable?4()
-gc.mem_alloc?4()
-gc.mem_free?4()
-gc.threshold?4(amount=None)
-hashlib.md5.digest?4()
-hashlib.md5.update?4(data)
-hashlib.md5?1(data=None)
-hashlib.sha1.digest?4()
-hashlib.sha1.update?4(data)
-hashlib.sha1?1(data=None)
-hashlib.sha256.digest?4()
-hashlib.sha256.update?4(data)
-hashlib.sha256?1(data=None)
-i2cslave.I2CSlave.deinit?4()
-i2cslave.I2CSlave.request?4(timeout=-1)
-i2cslave.I2CSlave?1(scl, sda, addresses, smbus=False)
-i2cslave.I2CSlaveRequest.ack?4(ack=True)
-i2cslave.I2CSlaveRequest.address?7
-i2cslave.I2CSlaveRequest.is_read?7
-i2cslave.I2CSlaveRequest.is_restart?7
-i2cslave.I2CSlaveRequest.read?4(n=-1, ack=True)
-i2cslave.I2CSlaveRequest.write?4(buffer)
-i2cslave.I2CSlaveRequest?1(slave, address, is_read, is_restart)
-math.acos?4(x)
-math.asin?4(x)
-math.atan2?4(y, x)
-math.atan?4(x)
-math.ceil?4(x)
-math.copysign?4(x, y)
-math.cos?4(x)
-math.degrees?4(x)
-math.e?7
-math.exp?4(x)
-math.fabs?4(x)
-math.floor?4(x)
-math.fmod?4(x, y)
-math.frexp?4(x)
-math.isfinite?4(x)
-math.isinf?4(x)
-math.isnan?4(x)
-math.ldexp?4(x, exp)
-math.modf?4(x)
-math.pi?7
-math.pow?4(x, y)
-math.radians?4(x)
-math.sin?4(x)
-math.sqrt?4(x)
-math.tan?4(x)
-math.trunc?4(x)
-microcontroller.Processor.frequency?7
-microcontroller.Processor.temperatur?7
-microcontroller.Processor.uid?7
-microcontroller.RunMode.BOOTLOADER?7
-microcontroller.RunMode.NORMAL?7
-microcontroller.RunMode.SAFE_MODE?7
-microcontroller.cpu?7
-microcontroller.delay_us?4(delay)
+frequencyio.FrequencyIn?1(pin: microcontroller.Pin, capture_period: int = 10)
+getpass.getpass?4(prompt: Optional[str] = "Password: ", stream: Optional[io.FileIO] = None)
+gifio.GifWriter.add_frame?4(bitmap: ReadableBuffer, delay: float = 0.1)
+gifio.GifWriter.deinit?4()
+gifio.GifWriter?1(file: Union[typing.BinaryIO, str], width: int, height: int, colorspace: displayio.Colorspace, loop: bool = True, dither: bool = False, )
+gnss.GNSS.deinit?4()
+gnss.GNSS.update?4()
+gnss.GNSS?1(system: Union[SatelliteSystem, List[SatelliteSystem]])
+gnss.PositionFix?1()
+gnss.SatelliteSystem?1()
+hashlib.Hash.digest?4()
+hashlib.Hash.update?4(data: ReadableBuffer)
+hashlib.new?4(name: str, data: bytes = b"")
+i2ctarget.I2CTarget.deinit?4()
+i2ctarget.I2CTarget.request?4(timeout: float = -1)
+i2ctarget.I2CTarget?1(scl: microcontroller.Pin, sda: microcontroller.Pin, addresses: Sequence[int], smbus: bool = False, )
+i2ctarget.I2CTargetRequest.ack?4(ack: bool = True)
+i2ctarget.I2CTargetRequest.read?4(n: int = -1, ack: bool = True)
+i2ctarget.I2CTargetRequest.write?4(buffer: ReadableBuffer)
+i2ctarget.I2CTargetRequest?1(target: i2ctarget.I2CTarget, address: int, is_read: bool, is_restart: bool)
+imagecapture.ParallelImageCapture.capture?4(buffer: WriteableBuffer)
+imagecapture.ParallelImageCapture.continuous_capture_get_frame?4()
+imagecapture.ParallelImageCapture.continuous_capture_start?4(buffer1: WriteableBuffer, buffer2: WriteableBuffer, /)
+imagecapture.ParallelImageCapture.continuous_capture_stop?4()
+imagecapture.ParallelImageCapture.deinit?4()
+imagecapture.ParallelImageCapture?1(*, data_pins: List[microcontroller.Pin], clock: microcontroller.Pin, vsync: Optional[microcontroller.Pin], href: Optional[microcontroller.Pin], )
+ipaddress.IPv4Address?1(address: Union[int, str, bytes])
+ipaddress.ip_address?4(obj: Union[int, str])
+is31fl3741.IS31FL3741.deinit?4()
+is31fl3741.IS31FL3741?1(i2c: busio.I2C, *, addr: int = 0x30)
+is31fl3741.IS31FL3741_FrameBuffer.deinit?4()
+is31fl3741.IS31FL3741_FrameBuffer.refresh?4()
+is31fl3741.IS31FL3741_FrameBuffer?1(is31: is31fl3741.IS31FL3741, width: int, height: int, mapping: Tuple[int, ...], *, framebuffer: Optional[WriteableBuffer] = None, scale: bool = False, gamma: bool = False, )
+is31fl3741.enable?4(self)
+is31fl3741.reset?4(self)
+is31fl3741.set_global_current?4(self, current: int)
+is31fl3741.set_led?4(self, led: int, value: int, page: int)
+is31fl3741.write?4(mapping: Tuple[int, ...], buf: ReadableBuffer)
+keypad.Event?1(key_number: int = 0, pressed: bool = True, timestamp: Optional[int] = None)
+keypad.EventQueue.clear?4()
+keypad.EventQueue.get?4()
+keypad.EventQueue.get_into?4(event: Event)
+keypad.KeyMatrix.deinit?4()
+keypad.KeyMatrix.key_number_to_row_column?4(key_number: int)
+keypad.KeyMatrix.reset?4()
+keypad.KeyMatrix.row_column_to_key_number?4(row: int, column: int)
+keypad.KeyMatrix?1(row_pins: Sequence[microcontroller.Pin], column_pins: Sequence[microcontroller.Pin], columns_to_anodes: bool = True, interval: float = 0.020, max_events: int = 64, )
+keypad.Keys.deinit?4()
+keypad.Keys.reset?4()
+keypad.Keys?1(pins: Sequence[microcontroller.Pin], *, value_when_pressed: bool, pull: bool = True, interval: float = 0.020, max_events: int = 64, )
+keypad.ShiftRegisterKeys.deinit?4()
+keypad.ShiftRegisterKeys.reset?4()
+keypad.ShiftRegisterKeys?1(*, clock: microcontroller.Pin, data: microcontroller.Pin, latch: microcontroller.Pin, value_to_latch: bool = True, key_count: int, value_when_pressed: bool, interval: float = 0.020, max_events: int = 64, )
+math.acos?4(x: float)
+math.acosh?4(x: float)
+math.asin?4(x: float)
+math.asinh?4(x: float)
+math.atan2?4(y: float, x: float)
+math.atan?4(x: float)
+math.atanh?4(x: float)
+math.ceil?4(x: float)
+math.copysign?4(x: float, y: float)
+math.cos?4(x: float)
+math.cosh?4(x: float)
+math.degrees?4(x: float)
+math.erf?4(x: float)
+math.erfc?4(x: float)
+math.exp?4(x: float)
+math.expm1?4(x: float)
+math.fabs?4(x: float)
+math.floor?4(x: float)
+math.fmod?4(x: float, y: float)
+math.frexp?4(x: float)
+math.gamma?4(x: float)
+math.isfinite?4(x: float)
+math.isinf?4(x: float)
+math.isnan?4(x: float)
+math.ldexp?4(x: float, exp: float)
+math.lgamma?4(x: float)
+math.log10?4(x: float)
+math.log2?4(x: float)
+math.log?4(x: float, base: float = e)
+math.modf?4(x: float)
+math.pow?4(x: float, y: float)
+math.radians?4(x: float)
+math.sin?4(x: float)
+math.sinh?4(x: float)
+math.sqrt?4(x: float)
+math.tan?4(x: float)
+math.tanh?4(x: float)
+math.trunc?4(x: float)
+mdns.RemoteService?1()
+mdns.Server.advertise_service?4(*, service_type: str, protocol: str, port: int)
+mdns.Server.deinit?4()
+mdns.Server.find?4(service_type: str, protocol: str, *, timeout: float = 1)
+mdns.Server?1(network_interface: wifi.Radio)
+memorymonitor.AllocationAlarm.ignore?4(count: int)
+memorymonitor.AllocationAlarm?1(*, minimum_block_count: int = 1)
+memorymonitor.AllocationSize?1()
+microcontroller.Pin?1()
+microcontroller.Processor?1()
+microcontroller.RunMode?1()
+microcontroller.delay_us?4(delay: int)
 microcontroller.disable_interrupts?4()
 microcontroller.enable_interrupts?4()
-microcontroller.nvm?7
-microcontroller.on_next_reset?4(run_mode)
-microcontroller.pin?7
+microcontroller.on_next_reset?4(run_mode: microcontroller.RunMode)
 microcontroller.reset?4()
-micropython.const?4(expr)
-micropython.heap_lock?4()
-micropython.heap_unlock?4()
-micropython.kbd_intr?4(chr)
-micropython.mem_info?4(verbose=False)
-micropython.opt_level?4(level=None)
-micropython.qstr_info?4(verbose=False)
-micropython.stack_use?4()
+msgpack.ExtType?1(code: int, data: bytes)
+msgpack.pack?4(obj: object, stream: circuitpython_typing.ByteStream, *, default: Union[Callable[[object], None], None] = None, )
+msgpack.unpack?4(stream: circuitpython_typing.ByteStream, *, ext_hook: Union[Callable[[int, bytes], object], None] = None, use_list: bool = True, )
 multiterminal.clear_secondary_terminal?4()
 multiterminal.get_secondary_terminal?4()
-multiterminal.schedule_secondary_terminal_read?4(socket)
-multiterminal.set_secondary_terminal?4(stream)
-neopixel_write.neopixel_write?4(digitalinout, buf)
-network.AP_IF?7
-network.AUTH_OPEN?7
-network.AUTH_WEP?7
-network.AUTH_WPA2_PSK?7
-network.AUTH_WPA_PSK?7
-network.AUTH_WPA_WPA2_PSK?7
-network.AbstractNIC.active?4(is_active=None)
-network.AbstractNIC.config?4(**params)
-network.AbstractNIC.connect?4(service_id=None, key=None, *args)
-network.AbstractNIC.disconnect?4()
-network.AbstractNIC.ifconfig?4(params=tuple())
-network.AbstractNIC.isconnected?4()
-network.AbstractNIC.scan?4(*args)
-network.AbstractNIC.status?4(param=None)
-network.AbstractNIC?1(id=None, *args)
-network.MODE_11B?7
-network.MODE_11G?7
-network.MODE_11N?7
-network.STAT_CONNECTING?7
-network.STAT_CONNECT_FAIL?7
-network.STAT_GOT_IP?7
-network.STAT_IDLE?7
-network.STAT_NO_AP_FOUND?7
-network.STAT_WRONG_PASSWORD?7
-network.STA_IF?7
-network.WLAN.active?4(is_active=None)
-network.WLAN.config?4(**params)
-network.WLAN.connect?4(ssid=None, password=None, *, bssid=None)
-network.WLAN.disconnect?4()
-network.WLAN.ifconfig?4(params=tuple())
-network.WLAN.isconnected?4()
-network.WLAN.scan?4()
-network.WLAN.status?4(param=None)
-network.WLAN?1(interface_id)
-network.phy_mode?4(mode=None)
-network.route?4()
-os.chdir?4(path)
+multiterminal.schedule_secondary_terminal_read?4(socket: socket.socket)
+multiterminal.set_secondary_terminal?4(stream: typing.BinaryIO)
+neopixel_write.neopixel_write?4(digitalinout: digitalio.DigitalInOut, buf: ReadableBuffer)
+nvm.ByteArray?1()
+onewireio.OneWire.deinit?4()
+onewireio.OneWire.read_bit?4()
+onewireio.OneWire.reset?4()
+onewireio.OneWire.write_bit?4(value: bool)
+onewireio.OneWire?1(pin: microcontroller.Pin)
+os.chdir?4(path: str)
 os.getcwd?4()
-os.listdir?4(dir=".")
-os.mkdir?4(path)
-os.remove?4(path)
-os.rename?4(old_path, new_path)
-os.rmdir?4(path)
-os.sep?7
-os.stat?4(path)
-os.statvfs?4(path)
+os.getenv?4(key: str, default: Optional[str] = None)
+os.listdir?4(dir: str)
+os.mkdir?4(path: str)
+os.remove?4(path: str)
+os.rename?4(old_path: str, new_path: str)
+os.rmdir?4(path: str)
+os.stat?4(path: str)
+os.statvfs?4(path: str)
 os.sync?4()
 os.uname?4()
-os.urandom?4(size)
+os.urandom?4(size: int)
+paralleldisplay.ParallelBus.reset?4()
+paralleldisplay.ParallelBus.send?4(command: int, data: ReadableBuffer)
+paralleldisplay.ParallelBus?1(*, data0: microcontroller.Pin, command: microcontroller.Pin, chip_select: microcontroller.Pin, write: microcontroller.Pin, read: Optional[microcontroller.Pin], reset: Optional[microcontroller.Pin] = None, frequency: int = 30_000_000, )
 ps2io.Ps2.clear_errors?4()
 ps2io.Ps2.deinit?4()
 ps2io.Ps2.popleft?4()
-ps2io.Ps2.sendcmd?4(byte)
-ps2io.Ps2?1(data_pin, clock_pin)
-pulseio.PWMOut.deinit?4()
-pulseio.PWMOut.duty_cycle?7
-pulseio.PWMOut.frequency?7
-pulseio.PWMOut?1(pin, *, duty_cycle=0, frequency=500, variable_frequency=False)
+ps2io.Ps2.sendcmd?4(byte: int)
+ps2io.Ps2?1(data_pin: microcontroller.Pin, clock_pin: microcontroller.Pin)
 pulseio.PulseIn.clear?4()
 pulseio.PulseIn.deinit?4()
-pulseio.PulseIn.maxlen?7
 pulseio.PulseIn.pause?4()
-pulseio.PulseIn.paused?7
 pulseio.PulseIn.popleft?4()
-pulseio.PulseIn.resume?4(trigger_duration=0)
-pulseio.PulseIn?1(pin, maxlen=2, *, idle_state=False)
+pulseio.PulseIn.resume?4(trigger_duration: int = 0)
+pulseio.PulseIn?1(pin: microcontroller.Pin, maxlen: int = 2, *, idle_state: bool = False)
 pulseio.PulseOut.deinit?4()
-pulseio.PulseOut.send?4(pulses)
-pulseio.PulseOut?1(carrier)
-random.choice?4(seq)
-random.getrandbits?4(k)
-random.randint?4(a, b)
+pulseio.PulseOut.send?4(pulses: ReadableBuffer)
+pulseio.PulseOut?1(pin: microcontroller.Pin, *, frequency: int = 38000, duty_cycle: int = 1 << 15, )
+pwmio.PWMOut.deinit?4()
+pwmio.PWMOut?1(pin: microcontroller.Pin, *, duty_cycle: int = 0, frequency: int = 500, variable_frequency: bool = False, )
+qrio.QRDecoder.decode?4(buffer: ReadableBuffer, pixel_policy: PixelPolicy = PixelPolicy.EVERY_BYTE)
+qrio.QRDecoder?1(width: int, height: int)
+rainbowio.colorwheel?4(n: float)
+random._T?8
+random.choice?4(seq: Sequence[_T])
+random.getrandbits?4(k: int)
+random.randint?4(a: int, b: int)
 random.random?4()
-random.randrange?4(start, stop, step=1)
-random.randrange?4(stop)
-random.seed?4(seed)
-random.uniform?4(a, b)
+random.randrange?4(start: int, stop: int)
+random.randrange?4(start: int, stop: int, step: int)
+random.randrange?4(stop: int)
+random.seed?4(seed: int)
+random.uniform?4(a: float, b: float)
+rgbmatrix.RGBMatrix.deinit?4()
+rgbmatrix.RGBMatrix.refresh?4()
+rgbmatrix.RGBMatrix?1(*, width: int, bit_depth: int, rgb_pins: Sequence[digitalio.DigitalInOut], addr_pins: Sequence[digitalio.DigitalInOut], clock_pin: digitalio.DigitalInOut, latch_pin: digitalio.DigitalInOut, output_enable_pin: digitalio.DigitalInOut, doublebuffer: bool = True, framebuffer: Optional[WriteableBuffer] = None, height: int = 0, tile: int = 1, serpentine: bool = True, )
 rotaryio.IncrementalEncoder.deinit?4()
-rotaryio.IncrementalEncoder.position?7
-rotaryio.IncrementalEncoder?1(pin_a, pin_b)
-rtc.RTC.calibration?7
-rtc.RTC.datetime?7
-rtc.set_time_source?4(rtc)
-samd.Clock.calibration?7
-samd.Clock.enabled?7
-samd.Clock.frequency?7
-samd.Clock.parent?7
-samd.clock?7
-socket.getaddrinfo?4(host, port)
-socket.socket.accept?4()
-socket.socket.bind?4(address)
-socket.socket.connect?4(address)
-socket.socket.listen?4(backlog)
-socket.socket.recv?4(bufsize)
-socket.socket.recv_into?4(buffer, bufsize=None)
-socket.socket.recvfrom?4(bufsize)
-socket.socket.send?4(bytes)
-socket.socket.sendto?4(bytes, address)
-socket.socket.setblocking?4(flag)
-socket.socket.setsockopt?4(level, optname, value)
-socket.socket.settimeout?4(value)
-socket.socket?1(family, type, proto)
-storage.VfsFat.ilistdir?4(path=None)
-storage.VfsFat.label?7
-storage.VfsFat.mkdir?4(path)
+rotaryio.IncrementalEncoder?1(pin_a: microcontroller.Pin, pin_b: microcontroller.Pin, divisor: int = 4)
+rp2pio.StateMachine.background_write?4(once: Optional[ReadableBuffer] = None, *, loop: Optional[ReadableBuffer] = None, swap: bool = False, )
+rp2pio.StateMachine.clear_rxfifo?4()
+rp2pio.StateMachine.clear_txstall?4()
+rp2pio.StateMachine.deinit?4()
+rp2pio.StateMachine.readinto?4(buffer: WriteableBuffer, *, start: int = 0, end: Optional[int] = None, swap: bool = False, )
+rp2pio.StateMachine.restart?4()
+rp2pio.StateMachine.run?4(instructions: ReadableBuffer)
+rp2pio.StateMachine.stop?4()
+rp2pio.StateMachine.stop_background_write?4()
+rp2pio.StateMachine.write?4(buffer: ReadableBuffer, *, start: int = 0, end: Optional[int] = None, swap: bool = False, )
+rp2pio.StateMachine.write_readinto?4(buffer_out: ReadableBuffer, buffer_in: WriteableBuffer, *, out_start: int = 0, out_end: Optional[int] = None, in_start: int = 0, in_end: Optional[int] = None, )
+rp2pio.StateMachine?1(program: ReadableBuffer, frequency: int, *, init: Optional[ReadableBuffer] = None, first_out_pin: Optional[microcontroller.Pin] = None, out_pin_count: int = 1, initial_out_pin_state: int = 0, initial_out_pin_direction: int = 0xFFFFFFFF, first_in_pin: Optional[microcontroller.Pin] = None, in_pin_count: int = 1, pull_in_pin_up: int = 0, pull_in_pin_down: int = 0, first_set_pin: Optional[microcontroller.Pin] = None, set_pin_count: int = 1, initial_set_pin_state: int = 0, initial_set_pin_direction: int = 0x1F, first_sideset_pin: Optional[microcontroller.Pin] = None, sideset_pin_count: int = 1, initial_sideset_pin_state: int = 0, initial_sideset_pin_direction: int = 0x1F, sideset_enable: bool = False, jmp_pin: Optional[microcontroller.Pin] = None, jmp_pin_pull: Optional[digitalio.Pull] = None, exclusive_pin_use: bool = True, auto_pull: bool = False, pull_threshold: int = 32, out_shift_right: bool = True, wait_for_txstall: bool = True, auto_push: bool = False, push_threshold: int = 32, in_shift_right: bool = True, user_interruptible: bool = True, wrap_target: int = 0, wrap: int = -1, )
+rp2pio.pins_are_sequential?4(pins: List[microcontroller.Pin])
+rtc.RTC?1()
+rtc.set_time_source?4(rtc: RTC)
+sdcardio.SDCard.count?4()
+sdcardio.SDCard.deinit?4()
+sdcardio.SDCard.readblocks?4(start_block: int, buf: WriteableBuffer)
+sdcardio.SDCard.sync?4()
+sdcardio.SDCard.writeblocks?4(start_block: int, buf: ReadableBuffer)
+sdcardio.SDCard?1(bus: busio.SPI, cs: microcontroller.Pin, baudrate: int = 8000000)
+sdioio.SDCard.configure?4(frequency: int = 0, width: int = 0)
+sdioio.SDCard.count?4()
+sdioio.SDCard.deinit?4()
+sdioio.SDCard.readblocks?4(start_block: int, buf: WriteableBuffer)
+sdioio.SDCard.writeblocks?4(start_block: int, buf: ReadableBuffer)
+sdioio.SDCard?1(clock: microcontroller.Pin, command: microcontroller.Pin, data: Sequence[microcontroller.Pin], frequency: int, )
+setup.STD_PACKAGES?7
+setup.build_package_data?4()
+setup.local_scheme?4(version)
+setup.package_data?7
+setup.package_dir?7
+setup.packages?7
+setup.stub_root?7
+setup.stubs?7
+socketpool.Socket.accept?4()
+socketpool.Socket.bind?4(address: Tuple[str, int])
+socketpool.Socket.close?4()
+socketpool.Socket.connect?4(address: Tuple[str, int])
+socketpool.Socket.listen?4(backlog: int)
+socketpool.Socket.recv_into?4(buffer: WriteableBuffer, bufsize: int)
+socketpool.Socket.recvfrom_into?4(buffer: WriteableBuffer)
+socketpool.Socket.send?4(bytes: ReadableBuffer)
+socketpool.Socket.sendto?4(bytes: ReadableBuffer, address: Tuple[str, int])
+socketpool.Socket.setblocking?4(flag: bool)
+socketpool.Socket.settimeout?4(value: int)
+socketpool.SocketPool.getaddrinfo?4(host: str, port: int, family: int = 0, type: int = 0, proto: int = 0, flags: int = 0, )
+socketpool.SocketPool.socket?4(family: int = AF_INET, type: int = SOCK_STREAM)
+socketpool.SocketPool?1(radio: wifi.Radio)
+ssl.SSLContext.load_verify_locations?4(cadata: Optional[str] = None)
+ssl.SSLContext.set_default_verify_paths?4()
+ssl.SSLContext.wrap_socket?4(sock: socketpool.Socket, *, server_side: bool = False, server_hostname: Optional[str] = None, )
+ssl.SSLSocket.accept?4()
+ssl.SSLSocket.bind?4(address: Tuple[str, int])
+ssl.SSLSocket.close?4()
+ssl.SSLSocket.connect?4(address: Tuple[str, int])
+ssl.SSLSocket.listen?4(backlog: int)
+ssl.SSLSocket.recv_into?4(buffer: WriteableBuffer, bufsize: int)
+ssl.SSLSocket.send?4(bytes: ReadableBuffer)
+ssl.SSLSocket.setblocking?4(flag: bool)
+ssl.SSLSocket.settimeout?4(value: int)
+ssl.create_default_context?4()
+storage.VfsFat.ilistdir?4(path: str)
+storage.VfsFat.mkdir?4(path: str)
 storage.VfsFat.mkfs?4()
-storage.VfsFat.open?4(path, mode)
-storage.VfsFat.rmdir?4(path)
-storage.VfsFat.stat?4(path)
-storage.VfsFat.statvfs?4(path)
-storage.VfsFat?1(block_device)
+storage.VfsFat.mount?4(readonly: bool, mkfs: VfsFat)
+storage.VfsFat.open?4(path: str, mode: str)
+storage.VfsFat.rmdir?4(path: str)
+storage.VfsFat.stat?4(path: str)
+storage.VfsFat.statvfs?4(path: int)
+storage.VfsFat.umount?4()
+storage.VfsFat?1(block_device: str)
+storage.disable_usb_drive?4()
+storage.enable_usb_drive?4()
 storage.erase_filesystem?4()
-storage.getmount?4(mount_path)
-storage.mount?4(filesystem, mount_path, *, readonly=False)
-storage.remount?4(mount_path, readonly=False, *, disable_concurrent_write_protection=False)
-storage.umount?4(mount)
-struct.calcsize?4(fmt)
-struct.pack?4(fmt, *values)
-struct.pack_into?4(fmt, buffer, offset, *values)
-struct.unpack?4(fmt, data)
-struct.unpack_from?4(fmt, data, offset=0)
-supervisor.Runtime.serial_bytes_available?7
-supervisor.Runtime.serial_connected?7
-supervisor.disable_autoreload?4()
-supervisor.enable_autoreload?4()
+storage.getmount?4(mount_path: str)
+storage.mount?4(filesystem: VfsFat, mount_path: str, *, readonly: bool = False)
+storage.remount?4(mount_path: str, readonly: bool = False, *, disable_concurrent_write_protection: bool = False, )
+storage.umount?4(mount: Union[str, VfsFat])
+struct.calcsize?4(fmt: str)
+struct.pack?4(fmt: str, *values: Any)
+struct.pack_into?4(fmt: str, buffer: WriteableBuffer, offset: int, *values: Any)
+struct.unpack?4(fmt: str, data: ReadableBuffer)
+struct.unpack_from?4(fmt: str, data: ReadableBuffer, offset: int = 0)
+supervisor.Runtime?1()
+supervisor.StatusBar?1()
+supervisor.disable_ble_workflow?4()
+supervisor.get_previous_traceback?4()
 supervisor.reload?4()
-supervisor.runtime?7
-supervisor.set_next_stack_limit?4(size)
-supervisor.set_rgb_status_brightness?4()
-sys.argv?7
-sys.byteorder?7
-sys.exit?4(retval=0)
-sys.implementation?7
-sys.maxsize?7
-sys.modules?7
-sys.path?7
-sys.platform?7
-sys.print_exception?4(exc, file=stdout)
-sys.stderr?7
-sys.stdin?7
-sys.stdout?7
-sys.version?7
-sys.version_info?7
-terminalio.FONT?7
-terminalio.Terminal.write?4(buf)
-terminalio.Terminal?1(tilegrid, font)
-time.localtime?4(secs=None)
-time.mktime?4(t)
+supervisor.reset_terminal?4(x_pixels: int, y_pixels: int)
+supervisor.set_next_code_file?4(filename: Optional[str], *, reload_on_success: bool = False, reload_on_error: bool = False, sticky_on_success: bool = False, sticky_on_error: bool = False, sticky_on_reload: bool = False, )
+supervisor.set_next_stack_limit?4(size: int)
+supervisor.set_rgb_status_brightness?4(brightness: int)
+supervisor.set_usb_identification?4(manufacturer: Optional[str] = None, product: Optional[str] = None, vid: int = -1, pid: int = -1, )
+supervisor.ticks_ms?4()
+synthio.MidiTrack.deinit?4()
+synthio.MidiTrack?1(buffer: ReadableBuffer, tempo: int, *, sample_rate: int = 11025)
+synthio.from_file?4(file: typing.BinaryIO, *, sample_rate: int = 11025)
+terminalio.Terminal.write?4(buf: ReadableBuffer)
+terminalio.Terminal?1(scroll_area: displayio.TileGrid, font: fontio.BuiltinFont, *, status_bar: displayio.TileGrid = None, )
+time.localtime?4(secs: int)
+time.mktime?4(t: struct_time)
 time.monotonic?4()
 time.monotonic_ns?4()
-time.sleep?4(seconds)
-time.struct_time?1(time_tuple)
+time.sleep?4(seconds: float)
+time.struct_time?1(time_tuple: Sequence[int])
 time.time?4()
 touchio.TouchIn.deinit?4()
-touchio.TouchIn.raw_value?7
-touchio.TouchIn.threshold?7
-touchio.TouchIn.value?7
-touchio.TouchIn?1(pin)
-uctypes.ARRAY?7
-uctypes.BIG_ENDIAN?7
-uctypes.FLOAT32?7
-uctypes.FLOAT64?7
-uctypes.INT16?7
-uctypes.INT32?7
-uctypes.INT64?7
-uctypes.INT8?7
-uctypes.LITTLE_ENDIAN?7
-uctypes.NATIVE?7
-uctypes.PTR?7
-uctypes.UINT16?7
-uctypes.UINT32?7
-uctypes.UINT64?7
-uctypes.UINT8?7
-uctypes.VOID?7
-uctypes.addressof?4(obj)
-uctypes.bytearray_at?4(addr, size)
-uctypes.bytes_at?4(addr, size)
-uctypes.sizeof?4(struct, layout_type=NATIVE)
-uctypes.struct?1(addr, descriptor, layout_type=NATIVE)
-uerrno.EACCES?7
-uerrno.EADDRINUSE?7
-uerrno.EAGAIN?7
-uerrno.EALREADY?7
-uerrno.EBADF?7
-uerrno.ECONNABORTED?7
-uerrno.ECONNREFUSED?7
-uerrno.ECONNRESET?7
-uerrno.EEXIST?7
-uerrno.EHOSTUNREACH?7
-uerrno.EINPROGRESS?7
-uerrno.EINVAL?7
-uerrno.EIO?7
-uerrno.EISDIR?7
-uerrno.ENOBUFS?7
-uerrno.ENODEV?7
-uerrno.ENOENT?7
-uerrno.ENOMEM?7
-uerrno.ENOTCONN?7
-uerrno.EOPNOTSUPP?7
-uerrno.EPERM?7
-uerrno.ETIMEDOUT?7
-uerrno.errorcode?7
-uheap.info?4(object)
-uheapq.heapify?4(x)
-uheapq.heappop?4(heap)
-uheapq.heappush?4(heap, item)
-uio.BytesIO.close?4()
-uio.BytesIO.flush?4()
-uio.BytesIO.getvalue?4()
-uio.BytesIO.read?4(size=-1)
-uio.BytesIO.readinto?4(b)
-uio.BytesIO.readline?4(size=-1)
-uio.BytesIO.seek?4(offset, whence=0)
-uio.BytesIO.write?4(b)
-uio.BytesIO?1(initial_value=b"")
-uio.FileIO.close?4()
-uio.FileIO.flush?4()
-uio.FileIO.read?4(size=-1)
-uio.FileIO.readinto?4(b)
-uio.FileIO.readline?4(size=-1)
-uio.FileIO.readlines?4(hint=-1)
-uio.FileIO.seek?4(offset, whence=0)
-uio.FileIO.tell?4()
-uio.FileIO.write?4(b)
-uio.FileIO?1(name, mode='r', **kwargs)
-uio.StringIO.close?4()
-uio.StringIO.flush?4()
-uio.StringIO.getvalue?4()
-uio.StringIO.read?4(size=-1)
-uio.StringIO.readinto?4(b)
-uio.StringIO.readline?4(size=-1)
-uio.StringIO.seek?4(offset, whence=0)
-uio.StringIO.write?4(s)
-uio.StringIO?1(initial_value="")
-uio.TextIOWrapper.close?4()
-uio.TextIOWrapper.flush?4()
-uio.TextIOWrapper.read?4(size=-1)
-uio.TextIOWrapper.readinto?4(b)
-uio.TextIOWrapper.readline?4(size=-1)
-uio.TextIOWrapper.readlines?4(hint=-1)
-uio.TextIOWrapper.seek?4(offset, whence=0)
-uio.TextIOWrapper.tell?4()
-uio.TextIOWrapper.write?4(s)
-uio.TextIOWrapper?1(name, mode='r', **kwargs)
-uio.open?4(name, mode='r', **kwargs)
-ujson.dump?4(obj, stream)
-ujson.dumps?4(obj)
-ujson.load?4(stream)
-ujson.loads?4(string)
-ure.DEBUG?7
-ure.compile?4(regex_str, flags=0)
-ure.match?4(regex_str, string)
-ure.match_object.end?4(index=0)
-ure.match_object.group?4(index)
-ure.match_object.groups?4()
-ure.match_object.span?4(index=0)
-ure.match_object.start?4(index=0)
-ure.regex_object.match?4(string)
-ure.regex_object.search?4(string)
-ure.regex_object.split?4(string, max_split=-1)
-ure.search?4(regex_str, string)
-usb_hid.Device.send_report?4(buf)
-usb_hid.Device.usage?7
-usb_hid.Device.usage_page?7
-usb_hid.devices?7
-usb_midi.PortIn.read?4(nbytes=None)
-usb_midi.PortIn.readinto?4(buf, nbytes=None)
-usb_midi.PortOut.write?4(buf)
-uselect.POLLERR?7
-uselect.POLLHUP?7
-uselect.POLLIN?7
-uselect.POLLOUT?7
-uselect.Poll.ipoll?4(timeout=-1, flags=0)
-uselect.Poll.modify?4(obj, eventmask)
-uselect.Poll.poll?4(timeout=-1)
-uselect.Poll.register?4(obj, eventmask = POLLIN | POLLOUT)
-uselect.Poll.unregister?4(obj)
-uselect.poll?4()
-uselect.select?4(rlist, wlist, xlist, timeout=-1)
-usocket.AF_INET6?7
-usocket.AF_INET?7
-usocket.IPPROTO_IP?7
-usocket.IPPROTO_SEC?7
-usocket.IPPROTO_TCP?7
-usocket.IPPROTO_UDP?7
-usocket.IP_ADD_MEMBERSHIP?7
-usocket.SOCK_DGRAM?7
-usocket.SOCK_RAW?7
-usocket.SOCK_STREAM?7
-usocket.SOL_SOCKET?7
-usocket.SO_REUSEADDR?7
-usocket.Socket.accept?4()
-usocket.Socket.bind?4(address)
-usocket.Socket.close?4()
-usocket.Socket.connect?4(address)
-usocket.Socket.listen?4(backlog=None)
-usocket.Socket.makefile?4(mode='rb', buffering=0)
-usocket.Socket.read?4(size=None)
-usocket.Socket.readinto?4(buf, nbytes=None)
-usocket.Socket.readline?4()
-usocket.Socket.recv?4(bufsize)
-usocket.Socket.recvfrom?4(bufsize)
-usocket.Socket.send?4(bytes)
-usocket.Socket.sendall?4(bytes)
-usocket.Socket.sendto?4(bytes, address)
-usocket.Socket.setblocking?4(flag)
-usocket.Socket.setsockopt?4(level, optname, value)
-usocket.Socket.settimeout?4(value)
-usocket.Socket.write?4(buf)
-usocket.error?7
-usocket.getaddrinfo?4(host, port, af=0, type=0, proto=0, flags=0)
-usocket.inet_ntop?4(af, bin_addr)
-usocket.inet_pton?4(af, txt_addr)
-usocket.socket?4(af=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP)
-ussl.CERT_NONE?7
-ussl.CERT_OPTIONAL?7
-ussl.CERT_REQUIRED?7
-ussl.wrap_socket?4(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None)
+touchio.TouchIn?1(pin: microcontroller.Pin)
+traceback.format_exception?4(etype: Type[BaseException], value: BaseException, tb: TracebackType, limit: Optional[int] = None, chain: Optional[bool] = True, )
+traceback.print_exception?4(etype: Type[BaseException], value: BaseException, tb: TracebackType, limit: Optional[int] = None, file: Optional[io.FileIO] = None, chain: Optional[bool] = True, )
+uheap.info?4(object: object)
+ulab.numpy._ArrayLike?8
+ulab.numpy._DType?8
+ulab.numpy.acos?4(a: _ArrayLike)
+ulab.numpy.acosh?4(a: _ArrayLike)
+ulab.numpy.arange?4(start: _float, stop: _float, step: _float = 1, *, dtype: _DType = ulab.numpy.float)
+ulab.numpy.arange?4(stop: _float, step: _float = 1, *, dtype: _DType = ulab.numpy.float)
+ulab.numpy.arctan2?4(ya: _ArrayLike, xa: _ArrayLike)
+ulab.numpy.argmax?4(array: _ArrayLike, *, axis: Optional[int] = None)
+ulab.numpy.argmin?4(array: _ArrayLike, *, axis: Optional[int] = None)
+ulab.numpy.argsort?4(array: ulab.numpy.ndarray, *, axis: int = -1)
+ulab.numpy.around?4(a: _ArrayLike, *, decimals: int = 0)
+ulab.numpy.array?4(values: Union[ndarray, Iterable[Union[_float, _bool, Iterable[Any]]]], *, dtype: _DType = ulab.numpy.float, )
+ulab.numpy.asin?4(a: _ArrayLike)
+ulab.numpy.asinh?4(a: _ArrayLike)
+ulab.numpy.atan?4(a: _ArrayLike)
+ulab.numpy.atanh?4(a: _ArrayLike)
+ulab.numpy.carray.abs?4(a: ulab.numpy.ndarray)
+ulab.numpy.carray.conjugate?4(val)
+ulab.numpy.carray.imag?4(val)
+ulab.numpy.carray.real?4(val)
+ulab.numpy.carray.sort_complex?4(a: ulab.numpy.ndarray)
+ulab.numpy.ceil?4(a: _ArrayLike)
+ulab.numpy.concatenate?4(arrays: Tuple[ulab.numpy.ndarray], *, axis: int = 0)
+ulab.numpy.cos?4(a: _ArrayLike)
+ulab.numpy.cosh?4(a: _ArrayLike)
+ulab.numpy.cross?4(a: ulab.numpy.ndarray, b: ulab.numpy.ndarray)
+ulab.numpy.degrees?4(a: _ArrayLike)
+ulab.numpy.diag?4(a: ulab.numpy.ndarray, *, k: int = 0)
+ulab.numpy.diff?4(array: ulab.numpy.ndarray, *, n: int = 1, axis: int = -1)
+ulab.numpy.dot?4(m1: ulab.numpy.ndarray, m2: ulab.numpy.ndarray)
+ulab.numpy.empty?4(shape: Union[int, Tuple[int, ...]], *, dtype: _DType = ulab.numpy.float)
+ulab.numpy.erf?4(a: _ArrayLike)
+ulab.numpy.erfc?4(a: _ArrayLike)
+ulab.numpy.exp?4(a: _ArrayLike)
+ulab.numpy.expm1?4(a: _ArrayLike)
+ulab.numpy.eye?4(size: int, *, M: Optional[int] = None, k: int = 0, dtype: _DType = ulab.numpy.float)
+ulab.numpy.fft.fft?4(r: ulab.numpy.ndarray, c: Optional[ulab.numpy.ndarray] = None)
+ulab.numpy.fft.ifft?4(r: ulab.numpy.ndarray, c: Optional[ulab.numpy.ndarray] = None)
+ulab.numpy.flip?4(array: ulab.numpy.ndarray, *, axis: Optional[int] = None)
+ulab.numpy.floor?4(a: _ArrayLike)
+ulab.numpy.full?4(shape: Union[int, Tuple[int, ...]], fill_value: Union[_float, _bool], *, dtype: _DType = ulab.numpy.float, )
+ulab.numpy.gamma?4(a: _ArrayLike)
+ulab.numpy.get_printoptions?4()
+ulab.numpy.interp?4(x: ulab.numpy.ndarray, xp: ulab.numpy.ndarray, fp: ulab.numpy.ndarray, *, left: Optional[_float] = None, right: Optional[_float] = None, )
+ulab.numpy.lgamma?4(a: _ArrayLike)
+ulab.numpy.linalg.cholesky?4(A: ulab.numpy.ndarray)
+ulab.numpy.linalg.det?4(m: ulab.numpy.ndarray)
+ulab.numpy.linalg.eig?4(m: ulab.numpy.ndarray)
+ulab.numpy.linalg.inv?4(m: ulab.numpy.ndarray)
+ulab.numpy.linalg.norm?4(x: ulab.numpy.ndarray)
+ulab.numpy.linalg.qr?4(m: ulab.numpy.ndarray)
+ulab.numpy.linspace?4(start: _float, stop: _float, *, dtype: _DType = ulab.numpy.float, num: int = 50, endpoint: _bool = True, retstep: _bool = False, )
+ulab.numpy.log10?4(a: _ArrayLike)
+ulab.numpy.log2?4(a: _ArrayLike)
+ulab.numpy.log?4(a: _ArrayLike)
+ulab.numpy.logspace?4(start: _float, stop: _float, *, dtype: _DType = ulab.numpy.float, num: int = 50, endpoint: _bool = True, base: _float = 10.0, )
+ulab.numpy.max?4(array: _ArrayLike, *, axis: Optional[int] = None)
+ulab.numpy.mean?4(array: _ArrayLike, *, axis: Optional[int] = None)
+ulab.numpy.median?4(array: ulab.numpy.ndarray, *, axis: int = -1)
+ulab.numpy.min?4(array: _ArrayLike, *, axis: Optional[int] = None)
+ulab.numpy.ndinfo?4(array: ulab.numpy.ndarray)
+ulab.numpy.ones?4(shape: Union[int, Tuple[int, ...]], *, dtype: _DType = ulab.numpy.float)
+ulab.numpy.radians?4(a: _ArrayLike)
+ulab.numpy.roll?4(array: ulab.numpy.ndarray, distance: int, *, axis: Optional[int] = None)
+ulab.numpy.set_printoptions?4(threshold: Optional[int] = None, edgeitems: Optional[int] = None)
+ulab.numpy.sin?4(a: _ArrayLike)
+ulab.numpy.sinh?4(a: _ArrayLike)
+ulab.numpy.sort?4(array: ulab.numpy.ndarray, *, axis: int = -1)
+ulab.numpy.sqrt?4(a: _ArrayLike)
+ulab.numpy.std?4(array: _ArrayLike, *, axis: Optional[int] = None, ddof: int = 0)
+ulab.numpy.sum?4(array: _ArrayLike, *, axis: Optional[int] = None)
+ulab.numpy.tan?4(a: _ArrayLike)
+ulab.numpy.tanh?4(a: _ArrayLike)
+ulab.numpy.trace?4(m: ulab.numpy.ndarray)
+ulab.numpy.trapz?4(y: ulab.numpy.ndarray, x: Optional[ulab.numpy.ndarray] = None, dx: _float = 1.0)
+ulab.numpy.vectorize?4(f: Union[Callable[[int], _float], Callable[[_float], _float]], *, otypes: Optional[_DType] = None, )
+ulab.numpy.zeros?4(shape: Union[int, Tuple[int, ...]], *, dtype: _DType = ulab.numpy.float)
+ulab.scipy.linalg.cho_solve?4(L: ulab.numpy.ndarray, b: ulab.numpy.ndarray)
+ulab.scipy.linalg.solve_triangular?4(A: ulab.numpy.ndarray, b: ulab.numpy.ndarray, lower: bool)
+ulab.scipy.optimize.bisect?4(fun: Callable[[float], float], a: float, b: float, *, xtol: float = 2.4e-7, maxiter: int = 100, )
+ulab.scipy.optimize.fmin?4(fun: Callable[[float], float], x0: float, *, xatol: float = 2.4e-7, fatol: float = 2.4e-7, maxiter: int = 200, )
+ulab.scipy.optimize.newton?4(fun: Callable[[float], float], x0: float, *, xtol: float = 2.4e-7, rtol: float = 0.0, maxiter: int = 50, )
+ulab.utils.spectrogram?4(r: ulab.numpy.ndarray)
+usb.core.Device.attach_kernel_driver?4(interface: int)
+usb.core.Device.ctrl_transfer?4(bmRequestType: int, bRequest: int, wValue: int = 0, wIndex: int = 0, data_or_wLength: Optional[array.array] = None, timeout: Optional[int] = None, )
+usb.core.Device.detach_kernel_driver?4(interface: int)
+usb.core.Device.is_kernel_driver_active?4(interface: int)
+usb.core.Device.read?4(endpoint: int, size_or_buffer: array.array, timeout: Optional[int] = None)
+usb.core.Device.write?4(endpoint: int, data: ReadableBuffer, timeout: Optional[int] = None)
+usb.core.Device?1()
+usb.core.find?4(find_all: bool = False, *, idVendor: Optional[int] = None, idProduct: Optional[int] = None, )
+usb_cdc.Serial.flush?4()
+usb_cdc.Serial.read?4(size: int = 1)
+usb_cdc.Serial.readinto?4(buf: WriteableBuffer)
+usb_cdc.Serial.readline?4(size: int = -1)
+usb_cdc.Serial.readlines?4()
+usb_cdc.Serial.reset_input_buffer?4()
+usb_cdc.Serial.reset_output_buffer?4()
+usb_cdc.Serial.write?4(buf: ReadableBuffer)
+usb_cdc.Serial?1()
+usb_cdc.disable?4()
+usb_cdc.enable?4(*, console: bool = True, data: bool = False)
+usb_hid.Device.get_last_received_report?4(report_id: Optional[int] = None)
+usb_hid.Device.send_report?4(report: ReadableBuffer, report_id: Optional[int] = None)
+usb_hid.Device?1(*, report_descriptor: ReadableBuffer, usage_page: int, usage: int, report_ids: Sequence[int], in_report_lengths: Sequence[int], out_report_lengths: Sequence[int], )
+usb_hid.disable?4()
+usb_hid.enable?4(devices: Optional[Sequence[Device]], boot_device: int = 0)
+usb_hid.get_boot_device?4()
+usb_host.Port.deinit?4()
+usb_host.Port?1(dp: microcontroller.Pin, dm: microcontroller.Pin)
+usb_midi.PortIn.read?4(nbytes: Optional[int] = None)
+usb_midi.PortIn.readinto?4(buf: WriteableBuffer, nbytes: Optional[int] = None)
+usb_midi.PortIn?1()
+usb_midi.PortOut.write?4(buf: ReadableBuffer)
+usb_midi.PortOut?1()
+usb_midi.disable?4()
+usb_midi.enable?4()
 ustack.max_stack_usage?4()
 ustack.stack_size?4()
 ustack.stack_usage?4()
-uzlib.DecompIO?1(stream, wbits=0)
-uzlib.decompress?4(data, wbits=0, bufsize=0)
-wiznet.WIZNET5K.connected?7
-wiznet.WIZNET5K.dhcp?7
-wiznet.WIZNET5K.ifconfig?4(params=None)
-wiznet.WIZNET5K?1(spi, cs, rst, dhcp=True)
+vectorio.Circle?1(pixel_shader: Union[displayio.ColorConverter, displayio.Palette], radius: int, x: int, y: int, )
+vectorio.Polygon?1(pixel_shader: Union[displayio.ColorConverter, displayio.Palette], points: List[Tuple[int, int]], x: int, y: int, )
+vectorio.Rectangle?1(pixel_shader: Union[displayio.ColorConverter, displayio.Palette], width: int, height: int, x: int, y: int, )
+watchdog.WatchDogMode?1()
+watchdog.WatchDogTimer.deinit?4()
+watchdog.WatchDogTimer.feed?4()
+watchdog.WatchDogTimer?1()
+wifi.Network?1()
+wifi.Radio.connect?4(ssid: Union[str | ReadableBuffer], password: Union[str | ReadableBuffer] = "", *, channel: Optional[int] = 0, bssid: Optional[Union[str | ReadableBuffer]] = "", timeout: Optional[float] = None, )
+wifi.Radio.ping?4(ip: ipaddress.IPv4Address, *, timeout: Optional[float] = 0.5)
+wifi.Radio.set_ipv4_address?4(*, ipv4: ipaddress.IPv4Address, netmask: ipaddress.IPv4Address, gateway: ipaddress.IPv4Address, ipv4_dns: Optional[ipaddress.IPv4Address], )
+wifi.Radio.start_ap?4(ssid: Union[str | ReadableBuffer], password: Union[str | ReadableBuffer] = "", *, channel: Optional[int] = 1, authmode: Optional[AuthMode], max_connections: Optional[int] = 4, )
+wifi.Radio.start_dhcp?4()
+wifi.Radio.start_scanning_networks?4(*, start_channel: int = 1, stop_channel: int = 11)
+wifi.Radio.start_station?4()
+wifi.Radio.stop_ap?4()
+wifi.Radio.stop_dhcp?4()
+wifi.Radio.stop_scanning_networks?4()
+wifi.Radio.stop_station?4()
+wifi.Radio?1()
+wifi.ScannedNetworks?1()
+wifi.deinit?4(self)
+wifi.lost?4(self)
+wifi.packet?4(self)
+wifi.queued?4(self)
+zlib.zlib_decompress?4(data: bytes, wbits: Optional[int] = 0, bufsize: Optional[int] = 0)