Mercurial Repositories > APIs / file revision

_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, )
_pixelmap.PixelMap.fill?4(color: PixelType)
_pixelmap.PixelMap.indices?4(index: int)
_pixelmap.PixelMap.show?4()
_pixelmap.PixelMap?1(pixelbuf: PixelBuf, indices: Tuple[Union[int, Tuple[int]]])
_pixelmap.PixelReturnSequence?7
_pixelmap.PixelReturnType?7
_pixelmap.PixelSequence?7
_pixelmap.PixelType?7
_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: Optional[digitalio.DigitalInOut] = None, *, baudrate: int = 100000, polarity: int = 0, phase: int = 0, extra_clocks: int = 0, )
adafruit_pixelbuf.PixelBuf.fill?4(color: PixelType)
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"", )
adafruit_pixelbuf.PixelReturnSequence?7
adafruit_pixelbuf.PixelReturnType?7
adafruit_pixelbuf.PixelSequence?7
adafruit_pixelbuf.PixelType?7
aesio.AES.decrypt_into?4(src: ReadableBuffer, dest: WriteableBuffer)
aesio.AES.encrypt_into?4(src: ReadableBuffer, dest: WriteableBuffer)
aesio.AES.rekey?4(key: ReadableBuffer, IV: Optional[ReadableBuffer] = None, )
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.readinto?4(buffer: WriteableBuffer)
analogbufio.BufferedIn?1(pin: microcontroller.Pin, *, sample_rate: int)
analogio.AnalogIn.deinit?4()
analogio.AnalogIn?1(pin: microcontroller.Pin)
analogio.AnalogOut.deinit?4()
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.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
audiobusio.I2SOut.resume?4()
audiobusio.I2SOut.stop?4()
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: 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?1(buffer: ReadableBuffer, *, channel_count: int = 1, sample_rate: int = 8000)
audiocore.WaveFile.deinit?4()
audiocore.WaveFile?1(file: Union[str, typing.BinaryIO], buffer: WriteableBuffer)
audioio.AudioOut.deinit?4()
audioio.AudioOut.pause?4()
audioio.AudioOut.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
audioio.AudioOut.resume?4()
audioio.AudioOut.stop?4()
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.play?4(sample: circuitpython_typing.AudioSample, *, loop: bool = False)
audiopwmio.PWMAudioOut.resume?4()
audiopwmio.PWMAudioOut.stop?4()
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: 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: 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(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: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize)
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_circle?4(dest_bitmap: displayio.Bitmap, x: int, y: int, radius: int, value: int)
bitmaptools.draw_line?4(dest_bitmap: displayio.Bitmap, x1: int, y1: int, x2: int, y2: int, value: int)
bitmaptools.draw_polygon?4(dest_bitmap: displayio.Bitmap, xs: ReadableBuffer, ys: ReadableBuffer, value: int, close: Optional[bool] = True, )
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()
busio.I2C.deinit?4()
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: 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.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: 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.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: ReadableBuffer)
busio.UART?1(tx: Optional[microcontroller.Pin] = None, rx: Optional[microcontroller.Pin] = None, *, rts: Optional[microcontroller.Pin] = None, cts: Optional[microcontroller.Pin] = None, rs485_dir: Optional[microcontroller.Pin] = None, rs485_invert: bool = False, 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()
cyw43.get_power_management?4()
cyw43.set_power_management?4(value: int)
digitalio.DigitalInOut.deinit?4()
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.deinit?4()
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: Union[int, circuitpython_typing.ReadableBuffer], 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, advanced_color_epaper: bool = False, two_byte_sequence_length: bool = False, start_up_time: float = 0, address_little_endian: 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, *, dither: bool = False)
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()
dualbank.flash?4(buffer: ReadableBuffer, offset: int = 0)
dualbank.switch?4()
espcamera.Camera.deinit?4()
espcamera.Camera.reconfigure?4(frame_size: Optional[FrameSize] = None, pixel_format: Optional[PixelFormat] = None, grab_mode: Optional[GrabMode] = None, framebuffer_count: Optional[int] = None, )
espcamera.Camera.take?4(timeout: Optional[float] = 0.25)
espcamera.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: Optional[microcontroller.Pin] = None, external_clock_frequency: int = 20_000_000, 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()
espnow.ESPNow.deinit?4()
espnow.ESPNow.read?4()
espnow.ESPNow.send?4(message: ReadableBuffer, peer: Optional[Peer] = None, )
espnow.ESPNow.set_pmk?4(pmk: ReadableBuffer)
espnow.ESPNow?1(buffer_size: int = 526, phy_rate: int = 0)
espnow.Peer?1(mac: bytes, *, lmk: Optional[bytes], channel: int = 0, interface: int = 0, encrypted: bool = False, )
espnow.Peers.append?4(peer: Peer)
espnow.Peers.remove?4(peer: Peer)
espnow.Peers?1()
espulp.ULP.deinit?4()
espulp.ULP.halt?4()
espulp.ULP.run?4(program: ReadableBuffer, *, pins: Sequence[microcontroller.Pin] = ())
espulp.ULP?1(arch: Architecture = Architecture.FSM)
espulp.ULPAlarm?1(ulp: ULP)
espulp.get_rtc_gpio_number?4(pin: microcontroller.Pin)
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: 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: 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, )
gifio.OnDiskGif.deinit?4()
gifio.OnDiskGif.next_frame?4()
gifio.OnDiskGif?1(file: str)
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)
memorymap.AddressRange?1(*, start, length)
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.on_next_reset?4(run_mode: microcontroller.RunMode)
microcontroller.reset?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, )
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.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: int)
os.utime?4(path: str, times: Tuple[int, 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, )
picodvi.Framebuffer.deinit?4()
picodvi.Framebuffer?1(width: int, height: int, *, clk_dp: microcontroller.Pin, clk_dn: microcontroller.Pin, red_dp: microcontroller.Pin, red_dn: microcontroller.Pin, green_dp: microcontroller.Pin, green_dn: microcontroller.Pin, blue_dp: microcontroller.Pin, blue_dn: microcontroller.Pin, color_depth: int = 8, )
ps2io.Ps2.clear_errors?4()
ps2io.Ps2.deinit?4()
ps2io.Ps2.popleft?4()
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.pause?4()
pulseio.PulseIn.popleft?4()
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: 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: 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?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
sharpdisplay.SharpMemoryFramebuffer.deinit?4()
sharpdisplay.SharpMemoryFramebuffer?1(spi_bus: busio.SPI, chip_select: microcontroller.Pin, width: int, height: int, baudrate: int = 2000000, jdi_display: bool = False, )
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.sendall?4(bytes: ReadableBuffer)
socketpool.Socket.sendto?4(bytes: ReadableBuffer, address: Tuple[str, int])
socketpool.Socket.setblocking?4(flag: bool)
socketpool.Socket.setsockopt?4(level: int, optname: int, value: int)
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_cert_chain?4(certfile: str, keyfile: str)
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.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: BlockDevice)
storage.disable_usb_drive?4()
storage.enable_usb_drive?4()
storage.erase_filesystem?4(extended: Optional[bool] = None)
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.get_previous_traceback?4()
supervisor.reload?4()
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_usb_identification?4(manufacturer: Optional[str] = None, product: Optional[str] = None, vid: int = -1, pid: int = -1, )
supervisor.ticks_ms?4()
synthio.Envelope?1(*, attack_time: Optional[float] = 0.1, decay_time: Optional[float] = 0.05, release_time: Optional[float] = 0.2, attack_level: Optional[float] = 1.0, sustain_level: Optional[float] = 0.8, )
synthio.MidiTrack.deinit?4()
synthio.MidiTrack?1(buffer: ReadableBuffer, tempo: int, *, sample_rate: int = 11025, waveform: Optional[ReadableBuffer] = None, envelope: Optional[Envelope] = None, )
synthio.Note?1(*, frequency: float, panning: float = 0.0, waveform: Optional[ReadableBuffer] = None, envelope: Optional[Envelope] = None, tremolo_depth: float = 0.0, tremolo_rate: float = 0.0, bend_depth: float = 0.0, bend_rate: float = 0.0, bend_mode: "BendMode" = BendMode.VIBRATO, )
synthio.NoteSequence?7
synthio.Synthesizer.deinit?4()
synthio.Synthesizer.press?4(/, press: NoteSequence = ())
synthio.Synthesizer.release?4(/, release: NoteSequence = ())
synthio.Synthesizer.release_all?4()
synthio.Synthesizer.release_all_then_press?4(/, press: NoteSequence)
synthio.Synthesizer.release_then_press?4(release: NoteSequence = (), press: NoteSequence = ())
synthio.Synthesizer?1(*, sample_rate: int = 11025, channel_count: int = 1, waveform: Optional[ReadableBuffer] = None, envelope: Optional[Envelope] = None, )
synthio.from_file?4(file: typing.BinaryIO, *, sample_rate: int = 11025, waveform: Optional[ReadableBuffer] = None, envelope: Optional[Envelope] = None, )
synthio.midi_to_hz?4(midi_note: float)
synthio.onevo_to_hz?4(ctrl: float)
terminalio.Terminal.write?4(buf: ReadableBuffer)
terminalio.Terminal?1(scroll_area: displayio.TileGrid, font: fontio.BuiltinFont, *, status_bar: Optional[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: float)
time.struct_time?1(time_tuple: Sequence[int])
time.time?4()
touchio.TouchIn.deinit?4()
touchio.TouchIn?1(pin: microcontroller.Pin)
traceback.format_exception?4(exc: BaseException | Type[BaseException], /, value: Optional[BaseException] = None, tb: Optional[TracebackType] = None, limit: Optional[int] = None, chain: Optional[bool] = True, )
traceback.print_exception?4(exc: BaseException | Type[BaseException], /, value: Optional[BaseException] = None, tb: Optional[TracebackType] = None, 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()
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.Monitor.deinit?4()
wifi.Monitor.lost?4()
wifi.Monitor.packet?4()
wifi.Monitor.queued?4()
wifi.Monitor?1(channel: Optional[int] = 1, queue: Optional[int] = 128)
wifi.Network?1()
wifi.Radio.connect?4(ssid: Union[str | ReadableBuffer], password: Union[str | ReadableBuffer] = b"", *, channel: int = 0, bssid: Optional[Union[str | ReadableBuffer]] = None, 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.set_ipv4_address_ap?4(*, ipv4: ipaddress.IPv4Address, netmask: ipaddress.IPv4Address, gateway: ipaddress.IPv4Address, )
wifi.Radio.start_ap?4(ssid: Union[str | ReadableBuffer], password: Union[str | ReadableBuffer] = b"", *, channel: int = 1, authmode: Optional[AuthMode] = None, max_connections: Optional[int] = 4, )
wifi.Radio.start_dhcp?4()
wifi.Radio.start_dhcp_ap?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_dhcp_ap?4()
wifi.Radio.stop_scanning_networks?4()
wifi.Radio.stop_station?4()
wifi.Radio?1()
wifi.ScannedNetworks?1()
zlib.zlib_decompress?4(data: bytes, wbits: Optional[int] = 0, bufsize: Optional[int] = 0)