From aa369fec094496ade563db118978024a5b671e28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81d=C3=A1m=20Kov=C3=A1cs?= Date: Fri, 24 Nov 2023 23:32:43 +0100 Subject: [PATCH] Add MicroPython generated files to gitignore --- .gitignore | 2 + .vscode/Pico-W-Stub/__builtins__.pyi | 3 +- .vscode/Pico-W-Stub/_asyncio.pyi | 48 +++- .vscode/Pico-W-Stub/_rp2.pyi | 256 ++++++++++++++++-- .vscode/Pico-W-Stub/aioble/central.pyi | 2 +- .vscode/Pico-W-Stub/aioble/client.pyi | 6 +- .vscode/Pico-W-Stub/aioble/device.pyi | 6 +- .vscode/Pico-W-Stub/array.pyi | 2 +- .vscode/Pico-W-Stub/asyncio/stream.pyi | 2 +- .vscode/Pico-W-Stub/io.pyi | 64 +++++ .vscode/Pico-W-Stub/machine.pyi | 6 +- .vscode/Pico-W-Stub/micropython.pyi | 42 ++- .../INSTALLER | 1 - .../LICENSE.md | 22 -- .../METADATA | 67 ----- .../RECORD | 99 ------- .../REQUESTED | 0 .../WHEEL | 4 - .vscode/Pico-W-Stub/neopixel.pyi | 55 +++- .vscode/Pico-W-Stub/rp2.pyi | 74 ++++- .vscode/Pico-W-Stub/socket.pyi | 45 +++ .vscode/Pico-W-Stub/uarray.pyi | 2 +- .vscode/Pico-W-Stub/uasyncio.pyi | 37 +++ .vscode/Pico-W-Stub/uio.pyi | 64 +++++ .vscode/Pico-W-Stub/umachine.pyi | 6 +- .vscode/Pico-W-Stub/usocket.pyi | 45 +++ 26 files changed, 715 insertions(+), 245 deletions(-) delete mode 100644 .vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/INSTALLER delete mode 100644 .vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/LICENSE.md delete mode 100644 .vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/METADATA delete mode 100644 .vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/RECORD delete mode 100644 .vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/REQUESTED delete mode 100644 .vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/WHEEL diff --git a/.gitignore b/.gitignore index 46b6cc3..e24be6a 100644 --- a/.gitignore +++ b/.gitignore @@ -160,3 +160,5 @@ cython_debug/ #.idea/ secrets.py settings.py + +.vscode/Pico-W-Stub \ No newline at end of file diff --git a/.vscode/Pico-W-Stub/__builtins__.pyi b/.vscode/Pico-W-Stub/__builtins__.pyi index 54df69e..5d9ece1 100644 --- a/.vscode/Pico-W-Stub/__builtins__.pyi +++ b/.vscode/Pico-W-Stub/__builtins__.pyi @@ -1,4 +1,5 @@ -# allows for type checking of additional builtins by pyright +"""Allows for type checking of Micropython specific builtins by pyright and pylance. +""" from typing import Tuple, TypeVar diff --git a/.vscode/Pico-W-Stub/_asyncio.pyi b/.vscode/Pico-W-Stub/_asyncio.pyi index bcaf545..b8137f9 100644 --- a/.vscode/Pico-W-Stub/_asyncio.pyi +++ b/.vscode/Pico-W-Stub/_asyncio.pyi @@ -1,4 +1,40 @@ -from _typeshed import Incomplete as Incomplete +""" +Asynchronous I/O scheduler for writing concurrent code. + +MicroPython module: https://docs.micropython.org/en/v1.21.0/library/asyncio.html + +CPython module: +`asyncio ` + +Example:: + + import asyncio + + async def blink(led, period_ms): + while True: + led.on() + await asyncio.sleep_ms(5) + led.off() + await asyncio.sleep_ms(period_ms) + + async def main(led1, led2): + asyncio.create_task(blink(led1, 700)) + asyncio.create_task(blink(led2, 400)) + await asyncio.sleep_ms(10_000) + + # Running on a pyboard + from pyb import LED + asyncio.run(main(LED(1), LED(2))) + + # Running on a generic board + from machine import Pin + asyncio.run(main(Pin(1), Pin(2))) + +Core functions +-------------- +""" +from _typeshed import Incomplete, Incomplete as Incomplete +from typing import Any, Coroutine, List, Tuple class TaskQueue: def push(self, *args, **kwargs) -> Incomplete: ... @@ -8,4 +44,12 @@ class TaskQueue: def __init__(self, *argv, **kwargs) -> None: ... class Task: - def __init__(self, *argv, **kwargs) -> None: ... + """ + This object wraps a coroutine into a running task. Tasks can be waited on + using ``await task``, which will wait for the task to complete and return + the return value of the task. + + Tasks should not be created directly, rather use `create_task` to create them. + """ + + def __init__(self) -> None: ... diff --git a/.vscode/Pico-W-Stub/_rp2.pyi b/.vscode/Pico-W-Stub/_rp2.pyi index 0603907..6ec2a9e 100644 --- a/.vscode/Pico-W-Stub/_rp2.pyi +++ b/.vscode/Pico-W-Stub/_rp2.pyi @@ -1,15 +1,58 @@ -from _typeshed import Incomplete as Incomplete +""" +Functionality specific to the RP2. + +MicroPython module: https://docs.micropython.org/en/v1.21.0/library/rp2.html + +The ``rp2`` module contains functions and classes specific to the RP2040, as +used in the Raspberry Pi Pico. + +See the `RP2040 Python datasheet +`_ +for more information, and `pico-micropython-examples +`_ +for example code. +""" +from _typeshed import Incomplete, Incomplete as Incomplete +from typing import Any, Optional def country(*args, **kwargs) -> Incomplete: ... -def bootsel_button(*args, **kwargs) -> Incomplete: ... +def bootsel_button() -> Incomplete: + """ + Temporarily turns the QSPI_SS pin into an input and reads its value, + returning 1 for low and 0 for high. + On a typical RP2040 board with a BOOTSEL button, a return value of 1 + indicates that the button is pressed. + + Since this function temporarily disables access to the external flash + memory, it also temporarily disables interrupts and the other core to + prevent them from trying to execute code from flash. + """ + ... class Flash: - def readblocks(self, *args, **kwargs) -> Incomplete: ... - def writeblocks(self, *args, **kwargs) -> Incomplete: ... - def ioctl(self, *args, **kwargs) -> Incomplete: ... - def __init__(self, *argv, **kwargs) -> None: ... + """ + Gets the singleton object for accessing the SPI flash memory. + """ + + def readblocks(self, block_num, buf, offset: Optional[int] = 0) -> Incomplete: ... + def writeblocks(self, block_num, buf, offset: Optional[int] = 0) -> Incomplete: ... + def ioctl(self, cmd, arg) -> Incomplete: + """ + These methods implement the simple and extended + :ref:`block protocol ` defined by + :class:`os.AbstractBlockDev`. + """ + ... + def __init__(self) -> None: ... class PIO: + """ + Gets the PIO instance numbered *id*. The RP2040 has two PIO instances, + numbered 0 and 1. + + Raises a ``ValueError`` if any other argument is provided. + """ + JOIN_TX: int JOIN_NONE: int JOIN_RX: int @@ -23,20 +66,191 @@ class PIO: IRQ_SM2: int IRQ_SM0: int IRQ_SM1: int - def state_machine(self, *args, **kwargs) -> Incomplete: ... - def remove_program(self, *args, **kwargs) -> Incomplete: ... - def irq(self, *args, **kwargs) -> Incomplete: ... - def add_program(self, *args, **kwargs) -> Incomplete: ... - def __init__(self, *argv, **kwargs) -> None: ... + def state_machine(self, id, program, *args, **kwargs) -> Incomplete: + """ + Gets the state machine numbered *id*. On the RP2040, each PIO instance has + four state machines, numbered 0 to 3. + + Optionally initialize it with a *program*: see `StateMachine.init`. + + >>> rp2.PIO(1).state_machine(3) + StateMachine(7) + """ + ... + def remove_program(self, program: Optional[Any] = None) -> None: + """ + Remove *program* from the instruction memory of this PIO instance. + + If no program is provided, it removes all programs. + + It is not an error to remove a program which has already been removed. + """ + ... + def irq(self, handler=None, trigger=IRQ_SM0, hard=False) -> Incomplete: + """ + Returns the IRQ object for this PIO instance. + + MicroPython only uses IRQ 0 on each PIO instance. IRQ 1 is not available. + + Optionally configure it. + """ + ... + def add_program(self, program) -> Incomplete: + """ + Add the *program* to the instruction memory of this PIO instance. + + The amount of memory available for programs on each PIO instance is + limited. If there isn't enough space left in the PIO's program memory + this method will raise ``OSError(ENOMEM)``. + """ + ... + def __init__(self, id) -> None: ... class StateMachine: - def irq(self, *args, **kwargs) -> Incomplete: ... - def put(self, *args, **kwargs) -> Incomplete: ... - def restart(self, *args, **kwargs) -> Incomplete: ... - def rx_fifo(self, *args, **kwargs) -> Incomplete: ... - def tx_fifo(self, *args, **kwargs) -> Incomplete: ... - def init(self, *args, **kwargs) -> Incomplete: ... - def exec(self, *args, **kwargs) -> Incomplete: ... - def get(self, *args, **kwargs) -> Incomplete: ... - def active(self, *args, **kwargs) -> Incomplete: ... - def __init__(self, *argv, **kwargs) -> None: ... + """ + Get the state machine numbered *id*. The RP2040 has two identical PIO + instances, each with 4 state machines: so there are 8 state machines in + total, numbered 0 to 7. + + Optionally initialize it with the given program *program*: see + `StateMachine.init`. + """ + + def irq(self, handler=None, trigger=0 | 1, hard=False) -> Incomplete: + """ + Returns the IRQ object for the given StateMachine. + + Optionally configure it. + """ + ... + def put(self, value, shift=0) -> Incomplete: + """ + Push words onto the state machine's TX FIFO. + + *value* can be an integer, an array of type ``B``, ``H`` or ``I``, or a + `bytearray`. + + This method will block until all words have been written to the FIFO. If + the FIFO is, or becomes, full, the method will block until the state machine + pulls enough words to complete the write. + + Each word is first shifted left by *shift* bits, i.e. the state machine + receives ``word << shift``. + """ + ... + def restart(self) -> Incomplete: + """ + Restarts the state machine and jumps to the beginning of the program. + + This method clears the state machine's internal state using the RP2040's + ``SM_RESTART`` register. This includes: + + - input and output shift counters + - the contents of the input shift register + - the delay counter + - the waiting-on-IRQ state + - a stalled instruction run using `StateMachine.exec()` + """ + ... + def rx_fifo(self) -> int: + """ + Returns the number of words in the state machine's RX FIFO. A value of 0 + indicates the FIFO is empty. + + Useful for checking if data is waiting to be read, before calling + `StateMachine.get()`. + """ + ... + def tx_fifo(self) -> int: + """ + Returns the number of words in the state machine's TX FIFO. A value of 0 + indicates the FIFO is empty. + + Useful for checking if there is space to push another word using + `StateMachine.put()`. + """ + ... + def init( + self, + program, + freq=-1, + *, + in_base=None, + out_base=None, + set_base=None, + jmp_pin=None, + sideset_base=None, + in_shiftdir=None, + out_shiftdir=None, + push_thresh=None, + pull_thresh=None, + ) -> None: + """ + Configure the state machine instance to run the given *program*. + + The program is added to the instruction memory of this PIO instance. If the + instruction memory already contains this program, then its offset is + re-used so as to save on instruction memory. + + - *freq* is the frequency in Hz to run the state machine at. Defaults to + the system clock frequency. + + The clock divider is computed as ``system clock frequency / freq``, so + there can be slight rounding errors. + + The minimum possible clock divider is one 65536th of the system clock: so + at the default system clock frequency of 125MHz, the minimum value of + *freq* is ``1908``. To run state machines at slower frequencies, you'll + need to reduce the system clock speed with `machine.freq()`. + - *in_base* is the first pin to use for ``in()`` instructions. + - *out_base* is the first pin to use for ``out()`` instructions. + - *set_base* is the first pin to use for ``set()`` instructions. + - *jmp_pin* is the first pin to use for ``jmp(pin, ...)`` instructions. + - *sideset_base* is the first pin to use for side-setting. + - *in_shiftdir* is the direction the ISR will shift, either + `PIO.SHIFT_LEFT` or `PIO.SHIFT_RIGHT`. + - *out_shiftdir* is the direction the OSR will shift, either + `PIO.SHIFT_LEFT` or `PIO.SHIFT_RIGHT`. + - *push_thresh* is the threshold in bits before auto-push or conditional + re-pushing is triggered. + - *pull_thresh* is the threshold in bits before auto-pull or conditional + re-pulling is triggered. + """ + ... + def exec(self, instr) -> Incomplete: + """ + Execute a single PIO instruction. + + If *instr* is a string then uses `asm_pio_encode` to encode the instruction + from the given string. + + >>> sm.exec("set(0, 1)") + + If *instr* is an integer then it is treated as an already encoded PIO + machine code instruction to be executed. + + >>> sm.exec(rp2.asm_pio_encode("out(y, 8)", 0)) + """ + ... + def get(self, buf=None, shift=0) -> Incomplete: + """ + Pull a word from the state machine's RX FIFO. + + If the FIFO is empty, it blocks until data arrives (i.e. the state machine + pushes a word). + + The value is shifted right by *shift* bits before returning, i.e. the + return value is ``word >> shift``. + """ + ... + def active(self, value: Optional[Any] = None) -> Incomplete: + """ + Gets or sets whether the state machine is currently running. + + >>> sm.active() + True + >>> sm.active(0) + False + """ + ... + def __init__(self, id, program, *args, **kwargs) -> None: ... diff --git a/.vscode/Pico-W-Stub/aioble/central.pyi b/.vscode/Pico-W-Stub/aioble/central.pyi index 984ea9f..2fa7065 100644 --- a/.vscode/Pico-W-Stub/aioble/central.pyi +++ b/.vscode/Pico-W-Stub/aioble/central.pyi @@ -46,7 +46,7 @@ class ScanResult: connectable: bool def __init__(self, device) -> None: ... def _update(self, adv_type, rssi, adv_data): ... - def __str__(self): ... + def __str__(self) -> str: ... def _decode_field(self, *adv_type) -> Generator[Incomplete, None, None]: ... def name(self): ... def services(self) -> Generator[Incomplete, None, None]: ... diff --git a/.vscode/Pico-W-Stub/aioble/client.pyi b/.vscode/Pico-W-Stub/aioble/client.pyi index 58da152..3c2754f 100644 --- a/.vscode/Pico-W-Stub/aioble/client.pyi +++ b/.vscode/Pico-W-Stub/aioble/client.pyi @@ -46,7 +46,7 @@ class ClientService: _end_handle: Incomplete uuid: Incomplete def __init__(self, connection, start_handle, end_handle, uuid) -> None: ... - def __str__(self): ... + def __str__(self) -> str: ... async def characteristic(self, uuid, timeout_ms: int = ...): ... def characteristics(self, uuid: Incomplete | None = ..., timeout_ms: int = ...): ... def _start_discovery(connection, uuid: Incomplete | None = ...) -> None: ... @@ -79,7 +79,7 @@ class ClientCharacteristic(BaseClientCharacteristic): _indicate_event: Incomplete _indicate_queue: Incomplete def __init__(self, service, end_handle, value_handle, properties, uuid) -> None: ... - def __str__(self): ... + def __str__(self) -> str: ... def _connection(self): ... async def descriptor(self, uuid, timeout_ms: int = ...): ... def descriptors(self, timeout_ms: int = ...): ... @@ -95,6 +95,6 @@ class ClientCharacteristic(BaseClientCharacteristic): class ClientDescriptor(BaseClientCharacteristic): characteristic: Incomplete def __init__(self, characteristic, dsc_handle, uuid) -> None: ... - def __str__(self): ... + def __str__(self) -> str: ... def _connection(self): ... def _start_discovery(characteristic, uuid: Incomplete | None = ...) -> None: ... diff --git a/.vscode/Pico-W-Stub/aioble/device.pyi b/.vscode/Pico-W-Stub/aioble/device.pyi index 07cfbc8..75c733a 100644 --- a/.vscode/Pico-W-Stub/aioble/device.pyi +++ b/.vscode/Pico-W-Stub/aioble/device.pyi @@ -15,7 +15,9 @@ class DeviceTimeout: def __init__(self, connection, timeout_ms) -> None: ... async def _timeout_sleep(self) -> None: ... def __enter__(self) -> None: ... - def __exit__(self, exc_type, exc_val, exc_traceback) -> None: ... + def __exit__( + self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_traceback: types.TracebackType | None + ) -> None: ... class Device: addr_type: Incomplete @@ -24,7 +26,7 @@ class Device: def __init__(self, addr_type, addr) -> None: ... def __eq__(self, rhs): ... def __hash__(self): ... - def __str__(self): ... + def __str__(self) -> str: ... def addr_hex(self): ... async def connect(self, timeout_ms: int = ...): ... diff --git a/.vscode/Pico-W-Stub/array.pyi b/.vscode/Pico-W-Stub/array.pyi index 8841b77..8000d09 100644 --- a/.vscode/Pico-W-Stub/array.pyi +++ b/.vscode/Pico-W-Stub/array.pyi @@ -12,7 +12,7 @@ floating-point support). from _typeshed import Incomplete, Incomplete as Incomplete from typing import Any, List, Optional -class array: +class array(List): """ Create array with elements of given type. Initial contents of the array are given by *iterable*. If it is not provided, an empty diff --git a/.vscode/Pico-W-Stub/asyncio/stream.pyi b/.vscode/Pico-W-Stub/asyncio/stream.pyi index 15521ab..20e2119 100644 --- a/.vscode/Pico-W-Stub/asyncio/stream.pyi +++ b/.vscode/Pico-W-Stub/asyncio/stream.pyi @@ -17,7 +17,7 @@ class Stream: def readexactly(self, n) -> Generator[Incomplete, None, Incomplete]: ... def readline(self) -> Generator[Incomplete, None, Incomplete]: ... def write(self, buf) -> None: ... - def drain(self) -> Generator[Incomplete, None, Incomplete]: ... + def drain(self) -> Generator[Incomplete, Incomplete, Incomplete]: ... StreamReader = Stream StreamWriter = Stream diff --git a/.vscode/Pico-W-Stub/io.pyi b/.vscode/Pico-W-Stub/io.pyi index 343844d..7e44ab1 100644 --- a/.vscode/Pico-W-Stub/io.pyi +++ b/.vscode/Pico-W-Stub/io.pyi @@ -7,6 +7,70 @@ CPython module: :mod:`python:io` https://docs.python.org/3/library/io.html . This module contains additional types of `stream` (file-like) objects and helper functions. + +Conceptual hierarchy +-------------------- + +Difference to CPython + + Conceptual hierarchy of stream base classes is simplified in MicroPython, + as described in this section. + +(Abstract) base stream classes, which serve as a foundation for behaviour +of all the concrete classes, adhere to few dichotomies (pair-wise +classifications) in CPython. In MicroPython, they are somewhat simplified +and made implicit to achieve higher efficiencies and save resources. + +An important dichotomy in CPython is unbuffered vs buffered streams. In +MicroPython, all streams are currently unbuffered. This is because all +modern OSes, and even many RTOSes and filesystem drivers already perform +buffering on their side. Adding another layer of buffering is counter- +productive (an issue known as "bufferbloat") and takes precious memory. +Note that there still cases where buffering may be useful, so we may +introduce optional buffering support at a later time. + +But in CPython, another important dichotomy is tied with "bufferedness" - +it's whether a stream may incur short read/writes or not. A short read +is when a user asks e.g. 10 bytes from a stream, but gets less, similarly +for writes. In CPython, unbuffered streams are automatically short +operation susceptible, while buffered are guarantee against them. The +no short read/writes is an important trait, as it allows to develop +more concise and efficient programs - something which is highly desirable +for MicroPython. So, while MicroPython doesn't support buffered streams, +it still provides for no-short-operations streams. Whether there will +be short operations or not depends on each particular class' needs, but +developers are strongly advised to favour no-short-operations behaviour +for the reasons stated above. For example, MicroPython sockets are +guaranteed to avoid short read/writes. Actually, at this time, there is +no example of a short-operations stream class in the core, and one would +be a port-specific class, where such a need is governed by hardware +peculiarities. + +The no-short-operations behaviour gets tricky in case of non-blocking +streams, blocking vs non-blocking behaviour being another CPython dichotomy, +fully supported by MicroPython. Non-blocking streams never wait for +data either to arrive or be written - they read/write whatever possible, +or signal lack of data (or ability to write data). Clearly, this conflicts +with "no-short-operations" policy, and indeed, a case of non-blocking +buffered (and this no-short-ops) streams is convoluted in CPython - in +some places, such combination is prohibited, in some it's undefined or +just not documented, in some cases it raises verbose exceptions. The +matter is much simpler in MicroPython: non-blocking stream are important +for efficient asynchronous operations, so this property prevails on +the "no-short-ops" one. So, while blocking streams will avoid short +reads/writes whenever possible (the only case to get a short read is +if end of file is reached, or in case of error (but errors don't +return short data, but raise exceptions)), non-blocking streams may +produce short data to avoid blocking the operation. + +The final dichotomy is binary vs text streams. MicroPython of course +supports these, but while in CPython text streams are inherently +buffered, they aren't in MicroPython. (Indeed, that's one of the cases +for which we may introduce buffering support.) + +Note that for efficiency, MicroPython doesn't provide abstract base +classes corresponding to the hierarchy above, and it's not possible +to implement, or subclass, a stream class in pure Python. """ from _typeshed import Incomplete, Incomplete as Incomplete from stdlib.io import * diff --git a/.vscode/Pico-W-Stub/machine.pyi b/.vscode/Pico-W-Stub/machine.pyi index 66b5aa7..a7e820d 100644 --- a/.vscode/Pico-W-Stub/machine.pyi +++ b/.vscode/Pico-W-Stub/machine.pyi @@ -983,14 +983,14 @@ class UART: poll.poll(timeout) """ ... - def write(self, buf) -> int: + def write(self, buf) -> Union[int, None]: """ Write the buffer of bytes to the bus. Return value: number of bytes written or ``None`` on timeout. """ ... - def readinto(self, buf, nbytes: Optional[Any] = None) -> int: + def readinto(self, buf, nbytes: Optional[Any] = None) -> Union[int, None]: """ Read bytes into the ``buf``. If ``nbytes`` is specified then read at most that many bytes. Otherwise, read at most ``len(buf)`` bytes. It may return sooner if a timeout @@ -1000,7 +1000,7 @@ class UART: timeout. """ ... - def readline(self) -> None: + def readline(self) -> Union[str, None]: """ Read a line, ending in a newline character. It may return sooner if a timeout is reached. The timeout is configurable in the constructor. diff --git a/.vscode/Pico-W-Stub/micropython.pyi b/.vscode/Pico-W-Stub/micropython.pyi index dfdc858..3d8e490 100644 --- a/.vscode/Pico-W-Stub/micropython.pyi +++ b/.vscode/Pico-W-Stub/micropython.pyi @@ -4,7 +4,7 @@ Access and control MicroPython internals. MicroPython module: https://docs.micropython.org/en/latest/library/micropython.html """ -# source version: v1_20_0 +# source version: v1_21_0 # origin module:: repos/micropython/docs/library/micropython.rst from typing import Any, Callable, Optional, Tuple, TypeVar, Union @@ -98,11 +98,9 @@ def stack_use() -> int: """ ... -def heap_lock() -> int: ... -def heap_unlock() -> int: ... -def heap_locked() -> bool: +def heap_lock() -> int: """ - Lock or unlock the heap. When locked no memory allocation can occur and a + Lock the heap. When locked no memory allocation can occur and a `MemoryError` will be raised if any heap allocation is attempted. `heap_locked()` returns a true value if the heap is currently locked. @@ -117,6 +115,40 @@ def heap_locked() -> bool: If the REPL becomes active with the heap locked then it will be forcefully unlocked. + Note: `heap_locked()` is not enabled on most ports by default, + requires ``MICROPY_PY_MICROPYTHON_HEAP_LOCKED``. + """ + ... +def heap_unlock() -> int: + """ + Unlock the heap. When locked no memory allocation can occur and a + `MemoryError` will be raised if any heap allocation is attempted. + `heap_locked()` returns a true value if the heap is currently locked. + + These functions can be nested, ie `heap_lock()` can be called multiple times + in a row and the lock-depth will increase, and then `heap_unlock()` must be + called the same number of times to make the heap available again. + + Both `heap_unlock()` and `heap_locked()` return the current lock depth + (after unlocking for the former) as a non-negative integer, with 0 meaning + the heap is not locked. + + If the REPL becomes active with the heap locked then it will be forcefully + unlocked. + + Note: `heap_locked()` is not enabled on most ports by default, + requires ``MICROPY_PY_MICROPYTHON_HEAP_LOCKED``. + """ + ... +def heap_locked() -> bool: + """ + Both `heap_unlock()` and `heap_locked()` return the current lock depth + (after unlocking for the former) as a non-negative integer, with 0 meaning + the heap is not locked. + + If the REPL becomes active with the heap locked then it will be forcefully + unlocked. + Note: `heap_locked()` is not enabled on most ports by default, requires ``MICROPY_PY_MICROPYTHON_HEAP_LOCKED``. """ diff --git a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/INSTALLER b/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/INSTALLER deleted file mode 100644 index a1b589e..0000000 --- a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/INSTALLER +++ /dev/null @@ -1 +0,0 @@ -pip diff --git a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/LICENSE.md b/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/LICENSE.md deleted file mode 100644 index 15d4b46..0000000 --- a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/LICENSE.md +++ /dev/null @@ -1,22 +0,0 @@ -MIT License - -Copyright (c) 2022 Jos Verlinde - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. - diff --git a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/METADATA b/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/METADATA deleted file mode 100644 index d9fe4d4..0000000 --- a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/METADATA +++ /dev/null @@ -1,67 +0,0 @@ -Metadata-Version: 2.1 -Name: micropython-rp2-rpi_pico_w-stubs -Version: 1.21.0.post1 -Summary: MicroPython stubs -Home-page: https://github.com/josverl/micropython-stubs#micropython-stubs -License: MIT -Author: josverl -Author-email: josverl@users.noreply.github.com -Requires-Python: >=3.8,<4.0 -Classifier: Development Status :: 4 - Beta -Classifier: License :: OSI Approved :: MIT License -Classifier: Operating System :: OS Independent -Classifier: Programming Language :: Python -Classifier: Programming Language :: Python :: 3 -Classifier: Programming Language :: Python :: 3.8 -Classifier: Programming Language :: Python :: 3.9 -Classifier: Programming Language :: Python :: 3.10 -Classifier: Programming Language :: Python :: 3.11 -Classifier: Programming Language :: Python :: 3 :: Only -Classifier: Programming Language :: Python :: Implementation :: MicroPython -Classifier: Topic :: Software Development :: Build Tools -Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) -Classifier: Typing :: Typed -Requires-Dist: micropython-stdlib-stubs (>=0.9.0) -Project-URL: Documentation, https://micropython-stubs.readthedocs.io/ -Project-URL: Repository, https://github.com/josverl/micropython-stubs -Description-Content-Type: text/markdown - -# micropython-rp2-rpi_pico_w-stubs - - -This is a stub-only package for MicroPython. -It is intended to be installed in a projects virtual environment to allow static type checkers and intellisense features to be used while writing Micropython code. - -The version of this package is alligned the the version of the MicroPython firmware. - - Major, Minor and Patch levels are alligned to the same version as the firmware. - - The post release level is used to publish new releases of the stubs. - -For `Micropython 1.17` the stubs are published as `1.17.post1` ... `1.17.post2` -for `Micropython 1.18` the stubs are published as `1.18.post1` ... `1.18.post2` - -To install the latest stubs: -`pip install -I micropython--stubs` where port is the port of the MicroPython firmware. - -To install the stubs for an older version, such as MicroPython 1.17: -`pip install micropython-stm32-stubs==1.17.*` which will install the last post release of the stubs for MicroPython 1.17. - - -As the creation of the stubs, and merging of the different types is still going though improvements, the stub packages are marked as Beta. -To upgrade stubs to the latest stubs for a specific version use `pip install micropython-stm32-stubs==1.17.* --upgrade` - -If you have suggestions or find any issues with the stubs, please report them in the [MicroPython-stubs Discussions](https://github.com/Josverl/micropython-stubs/discussions) - -For an overview of Micropython Stubs please see: https://micropython-stubs.readthedocs.io/en/main/ - * List of all stubs : https://micropython-stubs.readthedocs.io/en/main/firmware_grp.html - -Included stubs: -* Merged stubs from `stubs/micropython-v1_21_0-rp2-rpi_pico_w-merged` -* Frozen stubs from `stubs/micropython-v1_21_0-frozen/rp2/RPI_PICO_W` -* Core stubs from `stubs/micropython-core` - - -origin | Family | Port | Board | Version --------|--------|------|-------|-------- -Documentation | micropython | - | - | v1.21.0 -Core | micropython | rp2 | - | v1.21.0 - diff --git a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/RECORD b/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/RECORD deleted file mode 100644 index 9bcb19a..0000000 --- a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/RECORD +++ /dev/null @@ -1,99 +0,0 @@ -__builtins__.pyi,sha256=SRa_5xpV_qKoNdAgXY1G1TGP59HAYvZxp-ew4M2s3dY,1068 -_asyncio.pyi,sha256=oJgEZ1Axm6cN0eO1Ke7oj5YckMoicmwKfUO9vL_Y810,416 -_boot.pyi,sha256=sE1k2jzwUqn1o5YjnKlavj6468D8XQNhJNJ69gVrdtg,71 -_boot_fat.pyi,sha256=sE1k2jzwUqn1o5YjnKlavj6468D8XQNhJNJ69gVrdtg,71 -_onewire.pyi,sha256=_BXH4KbavKcoxnFA9OF24eERDydSk7EfXlx6N2mlBw8,343 -_rp2.pyi,sha256=MCGcgPRjp_mQlh3SN7TWalfzSXP6GAC2ojkCFPpSQj4,1556 -_thread.pyi,sha256=8qtf48y90MbHs4wEY_eSDeZ7QP__qf5DnYSJa7r18Ps,953 -aioble/__init__.pyi,sha256=Wjhrff1BWzqTqQh5pMss5q9gT51FhkzMF3tN_QV1cGc,600 -aioble/central.pyi,sha256=hZmbJnu3ccyO9Z9zjd29KiW6CGTvBmsNJx2Nv1nzLzo,2448 -aioble/client.pyi,sha256=KkXt3661i_eKYozYTW1BaZkZjbpOhrhfK1SBxKpC0eo,4180 -aioble/core.pyi,sha256=juai87amOQhoM_Vum3OTUcbkNiQVhXT3mYNyGzLLhe0,520 -aioble/device.pyi,sha256=7lzYKge6yfFNWwmwyViUQgEClY6lVXWKPneR4oCtifc,2311 -aioble/l2cap.pyi,sha256=k4NiXgzbvI25TqyfPbuWfu_v0KmF2dVXGtt3FuaicAs,1509 -aioble/peripheral.pyi,sha256=Rz6k4Jpk-_h6r_BAXp6-rwfnPMRcNJ8KT1uhiujugwM,1425 -aioble/security.pyi,sha256=-POdQrFOH67f9vtr2vbrf5U4TdZzipfx_qzRWDo6wEM,1071 -aioble/server.pyi,sha256=Wd4ESEM63-A-7q3sPS3ed6Pl19j4DVh112C2WqUCaxM,3364 -array.pyi,sha256=ZPtcObYk-XaI4AknOYrfMOJPXOS2ho0p35xdCgYcuVQ,1090 -asyncio/__init__.pyi,sha256=fa4aomSb_KMbJVCimrP6IfegajK_KSN8muiH_lbqc7k,132 -asyncio/core.pyi,sha256=xzNDXF3b6zq-OGz22ZPoPIJ_m5TVxgSg0YfUmG_CDzY,1530 -asyncio/event.pyi,sha256=fFBZxUa_PzdiiE8I14F9IZeqg9lJgIAH8s--6SBd-9E,623 -asyncio/funcs.pyi,sha256=3uEqPbVQPEqsaids5pFDkvmYUpufmkw4XuoyjwrouvI,390 -asyncio/lock.pyi,sha256=QF9HAL_ayvACAPYG9Rd2kB0-WeUFYPZazG-MFFVSvtE,414 -asyncio/stream.pyi,sha256=Uih1xMqHeZY4RwBQ4g-ut3_NauUjF10yxjGvh4Z3zeQ,1427 -binascii.pyi,sha256=kOai4wTFKZ1BQkyHe5WO2fkRDGST6eEetLS3KdtQ388,1488 -bluetooth.pyi,sha256=eKIXx2TJHUUHtKsSL4NawmGdnp02pCLbURKMQzSPvv0,30033 -cmath.pyi,sha256=Hvtu5G3iSwPeuJHZLWliHC3_g07MtMBEVErlOCRXqO0,1529 -collections.pyi,sha256=veeBTws6XDnpGS2N6sh0lKECaVflUC61SkJXbeakdeY,3966 -cryptolib.pyi,sha256=pV8vbhqweB83T5J70RwDAFpn9rNJSkHH5YZbS23EJ98,1739 -deflate.pyi,sha256=xraLamaDJ2rDZtVYjXLKlIM-F-E1xf8x4oA3qEgqeDM,3311 -dht.pyi,sha256=zamvhZo46pXwloiPKKlldLlMYmb7waNyZE1aeUnz-vA,344 -ds18x20.pyi,sha256=-BUsQj1Y155ooBHsobP6SzzNqWrw3SO8wnH3EpI9Z0A,404 -errno.pyi,sha256=fT9TQhrfWRbRou7wVcyJQWPysPh372koMw_GNZCC7SU,777 -framebuf.pyi,sha256=AlWAUXju3GDe8cD5SUFMb3iz90uLkbFet0BS64eDKUg,6474 -gc.pyi,sha256=rh6cpwqew57KbQm6aD92AY0cb0mSPM8KFrqxjQpLX6I,2524 -hashlib.pyi,sha256=9b65Uc6P92RHUGIgf00qCHOb2KSytlkRUnSNEj8q4r8,1743 -heapq.pyi,sha256=JE1S9UQ38DvuchjejRgb65S_tAYvK8CYYpQT4vEl4JA,1000 -io.pyi,sha256=ltx99WnM7_72vpSIRbTiiSh9Z5D90SbCeKaNrGISsOs,2702 -json.pyi,sha256=mP4C0XMgUt1ZcT7AQSteCY-n0rd0bREU_dnSQnjO5d0,1454 -lwip.pyi,sha256=0vIYgPwL5EnAbcoS1U2p_8e1SgPWiIYNevZDxMrO0kk,1582 -machine.pyi,sha256=HVtm4Fkv-HfqGxcE0koQVerU7acXqGkYBf8SKCKMPoM,50379 -math.pyi,sha256=KgjOuv3rpLNWcKWe7fVkB0PQ0Spv2VsBeE-pPhWNCWs,4827 -micropython.pyi,sha256=a72FE6dfhvby6MIVPeTOPcgh46wsJUyRJr4W4TJsGKA,8423 -micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 -micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/LICENSE.md,sha256=EerY3Evf4ZqwZBZMGIokOHR70txtsAlS_GGHuxmxUJY,1092 -micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/METADATA,sha256=i_ZZ0I4ExOQn4KCrRnXpajKX5Rdco9aYtYIPJdqAcds,3225 -micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/RECORD,, -micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88 -mip/__init__.pyi,sha256=Zd0De2fcvpCue3E5iPFUmmXdpf_IeciR9Pty29Id_fk,598 -neopixel.pyi,sha256=jOhE-kR8bRy0dEwqFLLY3Z7v7dp0n2XFwXTCwty0TuY,448 -network.pyi,sha256=OQjwBgmxsx5ICq3GCOL3vzqIfUBb4X_gUTEPJ9PWIQQ,7633 -ntptime.pyi,sha256=CmHJaGQFWjMig6JCTnWF0tY0KIw6jFWN362TnJWaWZQ,72 -onewire.pyi,sha256=DgLSo0kBX1ox2Qm0x76XY00m2x17GM0uh8J4GWU1Tgs,617 -os.pyi,sha256=BNYJHi5PymNeepTYUD27GoUDmXWrAreN3bIiU8-sB64,9677 -platform.pyi,sha256=3xuJleRh1wBIkS51WeiUkfQtwgYK1CLjDqXteBQIWaY,1463 -random.pyi,sha256=GDIgpkmplAsckapDEHlkkRdsRq8fCS_hBBRCS5gFmZI,2687 -requests.pyi,sha256=Mk3u-Y3RUz3YXbe8bkC5gzNE12dF8Z7SGEp0-lhckLQ,609 -requests/__init__.pyi,sha256=yNYrzq9TMRID3tAXLhHRRdzaiku2o6OfjDXjaF2bhYA,739 -rp2.pyi,sha256=ghYwOcTINmxwfGdaL3tE1z5soZvskgoBbjvSLiuOb2E,1918 -select.pyi,sha256=LKJ75d0F4BJg_7VAH3L07H1qqG3IkLuVEc82j-xMFWM,4114 -socket.pyi,sha256=YUTOaiosablCnk-corhGdTRNpQScrllJxdw9pZyWrYo,11622 -ssl.pyi,sha256=u94PkXN_NoaRnj2bBdMFq2x7JUHVmjeJcA8tvL1wMyI,3758 -struct.pyi,sha256=4Mf6SQIchLMnVNPnFG-iNgeIqqpaAYx89xvz1FAKJQA,4316 -sys.pyi,sha256=aL8EhWS78hy24Ir-y4QWB6QYdj5hYVooEiNQZ-MxMK0,1442 -time.pyi,sha256=Df5LIT2n7WwXRXjLKBlqQ7g0ZHsQe1mnkTdyKyAtYno,13313 -uarray.pyi,sha256=ZPtcObYk-XaI4AknOYrfMOJPXOS2ho0p35xdCgYcuVQ,1090 -uasyncio.pyi,sha256=eu4a7KxASOh_jGsRn7zmGtUt2rJYtOpjVuGYB4ty4fc,28 -uasyncio/__init__.pyi,sha256=bmpai6ZIJXDZ00aZz11BZZ92VGbfdQwqUL1jmUz3ZHU,2015 -uasyncio/core.pyi,sha256=6mmEJjdYJhiYRHY4c4Hs47AYuY2zEq_ZJXitr4XSlR8,1029 -uasyncio/event.pyi,sha256=OGzLIKk8AkbwIMK5l5CPy4QZTNc0uFQJzUftEgeUOzQ,580 -uasyncio/funcs.pyi,sha256=rHBK8jMGD6X6rvpy7jYMCukHJ1SxFg7GfAxlXug_XX0,147 -uasyncio/lock.pyi,sha256=LQ6j1whw6Oe2cRGT_gsQXkd16UrnsB5p33q8X73l220,259 -uasyncio/stream.pyi,sha256=89XP2eqkvEmo3VZTNC1V0IAne8b_xEkPJQfkiN0i6Mg,1746 -ubinascii.pyi,sha256=kOai4wTFKZ1BQkyHe5WO2fkRDGST6eEetLS3KdtQ388,1488 -ubluetooth.pyi,sha256=eKIXx2TJHUUHtKsSL4NawmGdnp02pCLbURKMQzSPvv0,30033 -ucollections.pyi,sha256=veeBTws6XDnpGS2N6sh0lKECaVflUC61SkJXbeakdeY,3966 -ucryptolib.pyi,sha256=pV8vbhqweB83T5J70RwDAFpn9rNJSkHH5YZbS23EJ98,1739 -uctypes.pyi,sha256=tUGuvBHmFbcLBOZCHZ--OKBe6dZdee-8B8ALYbTuV2Q,2417 -uerrno.pyi,sha256=fT9TQhrfWRbRou7wVcyJQWPysPh372koMw_GNZCC7SU,777 -uhashlib.pyi,sha256=9b65Uc6P92RHUGIgf00qCHOb2KSytlkRUnSNEj8q4r8,1743 -uheapq.pyi,sha256=JE1S9UQ38DvuchjejRgb65S_tAYvK8CYYpQT4vEl4JA,1000 -uio.pyi,sha256=ltx99WnM7_72vpSIRbTiiSh9Z5D90SbCeKaNrGISsOs,2702 -ujson.pyi,sha256=mP4C0XMgUt1ZcT7AQSteCY-n0rd0bREU_dnSQnjO5d0,1454 -umachine.pyi,sha256=HVtm4Fkv-HfqGxcE0koQVerU7acXqGkYBf8SKCKMPoM,50379 -uos.pyi,sha256=BNYJHi5PymNeepTYUD27GoUDmXWrAreN3bIiU8-sB64,9677 -uplatform.pyi,sha256=3xuJleRh1wBIkS51WeiUkfQtwgYK1CLjDqXteBQIWaY,1463 -urandom.pyi,sha256=GDIgpkmplAsckapDEHlkkRdsRq8fCS_hBBRCS5gFmZI,2687 -ure.pyi,sha256=bLeXSxERwfWOsjH_TCaRE4bcguKddfOgSAf2Bw9Fu7o,239 -urequests.pyi,sha256=eu4a7KxASOh_jGsRn7zmGtUt2rJYtOpjVuGYB4ty4fc,28 -uselect.pyi,sha256=LKJ75d0F4BJg_7VAH3L07H1qqG3IkLuVEc82j-xMFWM,4114 -usocket.pyi,sha256=YUTOaiosablCnk-corhGdTRNpQScrllJxdw9pZyWrYo,11622 -ussl.pyi,sha256=u94PkXN_NoaRnj2bBdMFq2x7JUHVmjeJcA8tvL1wMyI,3758 -ustruct.pyi,sha256=4Mf6SQIchLMnVNPnFG-iNgeIqqpaAYx89xvz1FAKJQA,4316 -usys.pyi,sha256=aL8EhWS78hy24Ir-y4QWB6QYdj5hYVooEiNQZ-MxMK0,1442 -utime.pyi,sha256=Df5LIT2n7WwXRXjLKBlqQ7g0ZHsQe1mnkTdyKyAtYno,13313 -uwebsocket.pyi,sha256=1wiEl4cRkoZE4jwWC-38w-Aowz3W5JZuv4KXHDYhsr8,469 -webrepl.pyi,sha256=Du-Qx0WvAvNFp5E6NG7a2lJv7m5z7KEWpUNRTCZmVO4,513 -webrepl_setup.pyi,sha256=3AjgA3EbRBgj6rUkxc_isYHihM-pCGnVANegahw1jfE,232 -websocket.pyi,sha256=1wiEl4cRkoZE4jwWC-38w-Aowz3W5JZuv4KXHDYhsr8,469 diff --git a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/REQUESTED b/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/REQUESTED deleted file mode 100644 index e69de29..0000000 diff --git a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/WHEEL b/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/WHEEL deleted file mode 100644 index 3695fd1..0000000 --- a/.vscode/Pico-W-Stub/micropython_rp2_rpi_pico_w_stubs-1.21.0.post1.dist-info/WHEEL +++ /dev/null @@ -1,4 +0,0 @@ -Wheel-Version: 1.0 -Generator: poetry-core 1.7.0 -Root-Is-Purelib: true -Tag: py3-none-any diff --git a/.vscode/Pico-W-Stub/neopixel.pyi b/.vscode/Pico-W-Stub/neopixel.pyi index 2273411..c4ba592 100644 --- a/.vscode/Pico-W-Stub/neopixel.pyi +++ b/.vscode/Pico-W-Stub/neopixel.pyi @@ -1,15 +1,58 @@ +""" +Control of WS2812 / NeoPixel LEDs. + +MicroPython module: https://docs.micropython.org/en/v1.21.0/library/neopixel.html + +This module provides a driver for WS2818 / NeoPixel LEDs. + +``Note:`` This module is only included by default on the ESP8266, ESP32 and RP2 + ports. On STM32 / Pyboard and others, you can either install the + ``neopixel`` package using :term:`mip`, or you can download the module + directly from :term:`micropython-lib` and copy it to the filesystem. +""" from _typeshed import Incomplete +from typing import Tuple class NeoPixel: + """ + Construct an NeoPixel object. The parameters are: + + - *pin* is a machine.Pin instance. + - *n* is the number of LEDs in the strip. + - *bpp* is 3 for RGB LEDs, and 4 for RGBW LEDs. + - *timing* is 0 for 400KHz, and 1 for 800kHz LEDs (most are 800kHz). + """ + ORDER: Incomplete pin: Incomplete n: Incomplete bpp: Incomplete buf: Incomplete timing: Incomplete - def __init__(self, pin, n, bpp: int = ..., timing: int = ...) -> None: ... - def __len__(self) -> int: ... - def __setitem__(self, i, v) -> None: ... - def __getitem__(self, i): ... - def fill(self, v) -> None: ... - def write(self) -> None: ... + def __init__(self, pin, n, *, bpp=3, timing=1) -> None: ... + def __len__(self) -> int: + """ + Returns the number of LEDs in the strip. + """ + ... + def __setitem__(self, index, val) -> None: + """ + Set the pixel at *index* to the value, which is an RGB/RGBW tuple. + """ + ... + def __getitem__(self, index) -> Tuple: + """ + Returns the pixel at *index* as an RGB/RGBW tuple. + """ + ... + def fill(self, pixel) -> None: + """ + Sets the value of all pixels to the specified *pixel* value (i.e. an + RGB/RGBW tuple). + """ + ... + def write(self) -> None: + """ + Writes the current pixel data to the strip. + """ + ... diff --git a/.vscode/Pico-W-Stub/rp2.pyi b/.vscode/Pico-W-Stub/rp2.pyi index 2ec5df9..ee01d1f 100644 --- a/.vscode/Pico-W-Stub/rp2.pyi +++ b/.vscode/Pico-W-Stub/rp2.pyi @@ -1,3 +1,17 @@ +""" +Functionality specific to the RP2. + +MicroPython module: https://docs.micropython.org/en/v1.21.0/library/rp2.html + +The ``rp2`` module contains functions and classes specific to the RP2040, as +used in the Raspberry Pi Pico. + +See the `RP2040 Python datasheet +`_ +for more information, and `pico-micropython-examples +`_ +for example code. +""" from _rp2 import * from _typeshed import Incomplete @@ -58,5 +72,61 @@ class PIOASMEmit: _pio_funcs: Incomplete -def asm_pio(**kw): ... -def asm_pio_encode(instr, sideset_count, sideset_opt: bool = ...): ... +def asm_pio( + *, + out_init=None, + set_init=None, + sideset_init=None, + in_shiftdir=0, + out_shiftdir=0, + autopush=False, + autopull=False, + push_thresh=32, + pull_thresh=32, + fifo_join=PIO.JOIN_NONE, +) -> Incomplete: + """ + Assemble a PIO program. + + The following parameters control the initial state of the GPIO pins, as one + of `PIO.IN_LOW`, `PIO.IN_HIGH`, `PIO.OUT_LOW` or `PIO.OUT_HIGH`. If the + program uses more than one pin, provide a tuple, e.g. + ``out_init=(PIO.OUT_LOW, PIO.OUT_LOW)``. + + - *out_init* configures the pins used for ``out()`` instructions. + - *set_init* configures the pins used for ``set()`` instructions. There can + be at most 5. + - *sideset_init* configures the pins used side-setting. There can be at + most 5. + + The following parameters are used by default, but can be overridden in + `StateMachine.init()`: + + - *in_shiftdir* is the default direction the ISR will shift, either + `PIO.SHIFT_LEFT` or `PIO.SHIFT_RIGHT`. + - *out_shiftdir* is the default direction the OSR will shift, either + `PIO.SHIFT_LEFT` or `PIO.SHIFT_RIGHT`. + - *push_thresh* is the threshold in bits before auto-push or conditional + re-pushing is triggered. + - *pull_thresh* is the threshold in bits before auto-pull or conditional + re-pulling is triggered. + + The remaining parameters are: + + - *autopush* configures whether auto-push is enabled. + - *autopull* configures whether auto-pull is enabled. + - *fifo_join* configures whether the 4-word TX and RX FIFOs should be + combined into a single 8-word FIFO for one direction only. The options + are `PIO.JOIN_NONE`, `PIO.JOIN_RX` and `PIO.JOIN_TX`. + """ + ... + +def asm_pio_encode(instr, sideset_count, sideset_opt=False) -> Incomplete: + """ + Assemble a single PIO instruction. You usually want to use `asm_pio()` + instead. + + >>> rp2.asm_pio_encode("set(0, 1)", 0) + 57345 + """ + ... diff --git a/.vscode/Pico-W-Stub/socket.pyi b/.vscode/Pico-W-Stub/socket.pyi index 86a1183..a93ffd2 100644 --- a/.vscode/Pico-W-Stub/socket.pyi +++ b/.vscode/Pico-W-Stub/socket.pyi @@ -14,6 +14,51 @@ Difference to CPython a file-like object using `makefile()` method. This method is still supported by MicroPython (but is a no-op), so where compatibility with CPython matters, be sure to use it. + +Socket address format(s) +------------------------ + +The native socket address format of the ``socket`` module is an opaque data type +returned by `getaddrinfo` function, which must be used to resolve textual address +(including numeric addresses):: + + sockaddr = socket.getaddrinfo('www.micropython.org', 80)[0][-1] + # You must use getaddrinfo() even for numeric addresses + sockaddr = socket.getaddrinfo('127.0.0.1', 80)[0][-1] + # Now you can use that address + sock.connect(sockaddr) + +Using `getaddrinfo` is the most efficient (both in terms of memory and processing +power) and portable way to work with addresses. + +However, ``socket`` module (note the difference with native MicroPython +``socket`` module described here) provides CPython-compatible way to specify +addresses using tuples, as described below. Note that depending on a +:term:`MicroPython port`, ``socket`` module can be builtin or need to be +installed from `micropython-lib` (as in the case of :term:`MicroPython Unix port`), +and some ports still accept only numeric addresses in the tuple format, +and require to use `getaddrinfo` function to resolve domain names. + +Summing up: + +* Always use `getaddrinfo` when writing portable applications. +* Tuple addresses described below can be used as a shortcut for + quick hacks and interactive use, if your port supports them. + +Tuple address format for ``socket`` module: + +* IPv4: *(ipv4_address, port)*, where *ipv4_address* is a string with + dot-notation numeric IPv4 address, e.g. ``"8.8.8.8"``, and *port* is and + integer port number in the range 1-65535. Note the domain names are not + accepted as *ipv4_address*, they should be resolved first using + `socket.getaddrinfo()`. +* IPv6: *(ipv6_address, port, flowinfo, scopeid)*, where *ipv6_address* + is a string with colon-notation numeric IPv6 address, e.g. ``"2001:db8::1"``, + and *port* is an integer port number in the range 1-65535. *flowinfo* + must be 0. *scopeid* is the interface scope identifier for link-local + addresses. Note the domain names are not accepted as *ipv6_address*, + they should be resolved first using `socket.getaddrinfo()`. Availability + of IPv6 support depends on a :term:`MicroPython port`. """ from _typeshed import Incomplete, Incomplete as Incomplete from stdlib.socket import * diff --git a/.vscode/Pico-W-Stub/uarray.pyi b/.vscode/Pico-W-Stub/uarray.pyi index 8841b77..8000d09 100644 --- a/.vscode/Pico-W-Stub/uarray.pyi +++ b/.vscode/Pico-W-Stub/uarray.pyi @@ -12,7 +12,7 @@ floating-point support). from _typeshed import Incomplete, Incomplete as Incomplete from typing import Any, List, Optional -class array: +class array(List): """ Create array with elements of given type. Initial contents of the array are given by *iterable*. If it is not provided, an empty diff --git a/.vscode/Pico-W-Stub/uasyncio.pyi b/.vscode/Pico-W-Stub/uasyncio.pyi index d53bcfb..0e94b10 100644 --- a/.vscode/Pico-W-Stub/uasyncio.pyi +++ b/.vscode/Pico-W-Stub/uasyncio.pyi @@ -1 +1,38 @@ +""" +Asynchronous I/O scheduler for writing concurrent code. + +MicroPython module: https://docs.micropython.org/en/v1.21.0/library/asyncio.html + +CPython module: +`asyncio ` + +Example:: + + import asyncio + + async def blink(led, period_ms): + while True: + led.on() + await asyncio.sleep_ms(5) + led.off() + await asyncio.sleep_ms(period_ms) + + async def main(led1, led2): + asyncio.create_task(blink(led1, 700)) + asyncio.create_task(blink(led2, 400)) + await asyncio.sleep_ms(10_000) + + # Running on a pyboard + from pyb import LED + asyncio.run(main(LED(1), LED(2))) + + # Running on a generic board + from machine import Pin + asyncio.run(main(Pin(1), Pin(2))) + +Core functions +-------------- +""" +from _typeshed import Incomplete + def __getattr__(attr): ... diff --git a/.vscode/Pico-W-Stub/uio.pyi b/.vscode/Pico-W-Stub/uio.pyi index 343844d..7e44ab1 100644 --- a/.vscode/Pico-W-Stub/uio.pyi +++ b/.vscode/Pico-W-Stub/uio.pyi @@ -7,6 +7,70 @@ CPython module: :mod:`python:io` https://docs.python.org/3/library/io.html . This module contains additional types of `stream` (file-like) objects and helper functions. + +Conceptual hierarchy +-------------------- + +Difference to CPython + + Conceptual hierarchy of stream base classes is simplified in MicroPython, + as described in this section. + +(Abstract) base stream classes, which serve as a foundation for behaviour +of all the concrete classes, adhere to few dichotomies (pair-wise +classifications) in CPython. In MicroPython, they are somewhat simplified +and made implicit to achieve higher efficiencies and save resources. + +An important dichotomy in CPython is unbuffered vs buffered streams. In +MicroPython, all streams are currently unbuffered. This is because all +modern OSes, and even many RTOSes and filesystem drivers already perform +buffering on their side. Adding another layer of buffering is counter- +productive (an issue known as "bufferbloat") and takes precious memory. +Note that there still cases where buffering may be useful, so we may +introduce optional buffering support at a later time. + +But in CPython, another important dichotomy is tied with "bufferedness" - +it's whether a stream may incur short read/writes or not. A short read +is when a user asks e.g. 10 bytes from a stream, but gets less, similarly +for writes. In CPython, unbuffered streams are automatically short +operation susceptible, while buffered are guarantee against them. The +no short read/writes is an important trait, as it allows to develop +more concise and efficient programs - something which is highly desirable +for MicroPython. So, while MicroPython doesn't support buffered streams, +it still provides for no-short-operations streams. Whether there will +be short operations or not depends on each particular class' needs, but +developers are strongly advised to favour no-short-operations behaviour +for the reasons stated above. For example, MicroPython sockets are +guaranteed to avoid short read/writes. Actually, at this time, there is +no example of a short-operations stream class in the core, and one would +be a port-specific class, where such a need is governed by hardware +peculiarities. + +The no-short-operations behaviour gets tricky in case of non-blocking +streams, blocking vs non-blocking behaviour being another CPython dichotomy, +fully supported by MicroPython. Non-blocking streams never wait for +data either to arrive or be written - they read/write whatever possible, +or signal lack of data (or ability to write data). Clearly, this conflicts +with "no-short-operations" policy, and indeed, a case of non-blocking +buffered (and this no-short-ops) streams is convoluted in CPython - in +some places, such combination is prohibited, in some it's undefined or +just not documented, in some cases it raises verbose exceptions. The +matter is much simpler in MicroPython: non-blocking stream are important +for efficient asynchronous operations, so this property prevails on +the "no-short-ops" one. So, while blocking streams will avoid short +reads/writes whenever possible (the only case to get a short read is +if end of file is reached, or in case of error (but errors don't +return short data, but raise exceptions)), non-blocking streams may +produce short data to avoid blocking the operation. + +The final dichotomy is binary vs text streams. MicroPython of course +supports these, but while in CPython text streams are inherently +buffered, they aren't in MicroPython. (Indeed, that's one of the cases +for which we may introduce buffering support.) + +Note that for efficiency, MicroPython doesn't provide abstract base +classes corresponding to the hierarchy above, and it's not possible +to implement, or subclass, a stream class in pure Python. """ from _typeshed import Incomplete, Incomplete as Incomplete from stdlib.io import * diff --git a/.vscode/Pico-W-Stub/umachine.pyi b/.vscode/Pico-W-Stub/umachine.pyi index 66b5aa7..a7e820d 100644 --- a/.vscode/Pico-W-Stub/umachine.pyi +++ b/.vscode/Pico-W-Stub/umachine.pyi @@ -983,14 +983,14 @@ class UART: poll.poll(timeout) """ ... - def write(self, buf) -> int: + def write(self, buf) -> Union[int, None]: """ Write the buffer of bytes to the bus. Return value: number of bytes written or ``None`` on timeout. """ ... - def readinto(self, buf, nbytes: Optional[Any] = None) -> int: + def readinto(self, buf, nbytes: Optional[Any] = None) -> Union[int, None]: """ Read bytes into the ``buf``. If ``nbytes`` is specified then read at most that many bytes. Otherwise, read at most ``len(buf)`` bytes. It may return sooner if a timeout @@ -1000,7 +1000,7 @@ class UART: timeout. """ ... - def readline(self) -> None: + def readline(self) -> Union[str, None]: """ Read a line, ending in a newline character. It may return sooner if a timeout is reached. The timeout is configurable in the constructor. diff --git a/.vscode/Pico-W-Stub/usocket.pyi b/.vscode/Pico-W-Stub/usocket.pyi index 86a1183..a93ffd2 100644 --- a/.vscode/Pico-W-Stub/usocket.pyi +++ b/.vscode/Pico-W-Stub/usocket.pyi @@ -14,6 +14,51 @@ Difference to CPython a file-like object using `makefile()` method. This method is still supported by MicroPython (but is a no-op), so where compatibility with CPython matters, be sure to use it. + +Socket address format(s) +------------------------ + +The native socket address format of the ``socket`` module is an opaque data type +returned by `getaddrinfo` function, which must be used to resolve textual address +(including numeric addresses):: + + sockaddr = socket.getaddrinfo('www.micropython.org', 80)[0][-1] + # You must use getaddrinfo() even for numeric addresses + sockaddr = socket.getaddrinfo('127.0.0.1', 80)[0][-1] + # Now you can use that address + sock.connect(sockaddr) + +Using `getaddrinfo` is the most efficient (both in terms of memory and processing +power) and portable way to work with addresses. + +However, ``socket`` module (note the difference with native MicroPython +``socket`` module described here) provides CPython-compatible way to specify +addresses using tuples, as described below. Note that depending on a +:term:`MicroPython port`, ``socket`` module can be builtin or need to be +installed from `micropython-lib` (as in the case of :term:`MicroPython Unix port`), +and some ports still accept only numeric addresses in the tuple format, +and require to use `getaddrinfo` function to resolve domain names. + +Summing up: + +* Always use `getaddrinfo` when writing portable applications. +* Tuple addresses described below can be used as a shortcut for + quick hacks and interactive use, if your port supports them. + +Tuple address format for ``socket`` module: + +* IPv4: *(ipv4_address, port)*, where *ipv4_address* is a string with + dot-notation numeric IPv4 address, e.g. ``"8.8.8.8"``, and *port* is and + integer port number in the range 1-65535. Note the domain names are not + accepted as *ipv4_address*, they should be resolved first using + `socket.getaddrinfo()`. +* IPv6: *(ipv6_address, port, flowinfo, scopeid)*, where *ipv6_address* + is a string with colon-notation numeric IPv6 address, e.g. ``"2001:db8::1"``, + and *port* is an integer port number in the range 1-65535. *flowinfo* + must be 0. *scopeid* is the interface scope identifier for link-local + addresses. Note the domain names are not accepted as *ipv6_address*, + they should be resolved first using `socket.getaddrinfo()`. Availability + of IPv6 support depends on a :term:`MicroPython port`. """ from _typeshed import Incomplete, Incomplete as Incomplete from stdlib.socket import *