first save

.venv/lib/python3.12/site-packages/select.pyi

@@ -0,0 +1,123 @@
+"""
+Wait for events on a set of streams.
+
+MicroPython module: https://docs.micropython.org/en/v1.26.0/library/select.html
+
+CPython module: :mod:`python:select` https://docs.python.org/3/library/select.html .
+
+This module provides functions to efficiently wait for events on multiple
+`streams <stream>` (select streams which are ready for operations).
+
+---
+Module: 'select' on micropython-v1.26.0-rp2-RPI_PICO
+"""
+
+# MCU: {'mpy': 'v6.3', 'build': '', 'ver': '1.26.0', 'arch': 'armv6m', 'version': '1.26.0', 'port': 'rp2', 'board': 'RPI_PICO', 'family': 'micropython', 'board_id': 'RPI_PICO', 'variant': '', 'cpu': 'RP2040'}
+# Stubber: v1.26.0
+from __future__ import annotations
+from typing import Any, Iterable, Iterator, List, Optional, Tuple, Final
+from _typeshed import Incomplete
+from typing_extensions import Awaitable, TypeAlias, TypeVar
+
+POLLOUT: Final[int] = 4
+POLLIN: Final[int] = 1
+POLLHUP: Final[int] = 16
+POLLERR: Final[int] = 8
+
+def select(
+    rlist: Iterable[Any],
+    wlist: Iterable[Any],
+    xlist: Iterable[Any],
+    timeout: int = -1,
+    /,
+) -> None:
+    """
+    Wait for activity on a set of objects.
+
+    This function is provided by some MicroPython ports for compatibility
+    and is not efficient. Usage of :class:`Poll` is recommended instead.
+    """
+    ...
+
+class poll:
+    """
+    Create an instance of the Poll class.
+    """
+
+    def __init__(self) -> None: ...
+    def register(self, obj, eventmask: Optional[Any] = None) -> None:
+        """
+        Register `stream` *obj* for polling. *eventmask* is logical OR of:
+
+        * ``select.POLLIN``  - data available for reading
+        * ``select.POLLOUT`` - more data can be written
+
+        Note that flags like ``select.POLLHUP`` and ``select.POLLERR`` are
+        *not* valid as input eventmask (these are unsolicited events which
+        will be returned from `poll()` regardless of whether they are asked
+        for). This semantics is per POSIX.
+
+        *eventmask* defaults to ``select.POLLIN | select.POLLOUT``.
+
+        It is OK to call this function multiple times for the same *obj*.
+        Successive calls will update *obj*'s eventmask to the value of
+        *eventmask* (i.e. will behave as `modify()`).
+        """
+        ...
+
+    def unregister(self, obj) -> Incomplete:
+        """
+        Unregister *obj* from polling.
+        """
+        ...
+
+    def modify(self, obj, eventmask) -> None:
+        """
+        Modify the *eventmask* for *obj*. If *obj* is not registered, `OSError`
+        is raised with error of ENOENT.
+        """
+        ...
+
+    def poll(self, timeout=-1, /) -> List:
+        """
+        Wait for at least one of the registered objects to become ready or have an
+        exceptional condition, with optional timeout in milliseconds (if *timeout*
+        arg is not specified or -1, there is no timeout).
+
+        Returns list of (``obj``, ``event``, ...) tuples. There may be other elements in
+        tuple, depending on a platform and version, so don't assume that its size is 2.
+        The ``event`` element specifies which events happened with a stream and
+        is a combination of ``select.POLL*`` constants described above. Note that
+        flags ``select.POLLHUP`` and ``select.POLLERR`` can be returned at any time
+        (even if were not asked for), and must be acted on accordingly (the
+        corresponding stream unregistered from poll and likely closed), because
+        otherwise all further invocations of `poll()` may return immediately with
+        these flags set for this stream again.
+
+        In case of timeout, an empty list is returned.
+
+        Admonition:Difference to CPython
+           :class: attention
+
+           Tuples returned may contain more than 2 elements as described above.
+        """
+        ...
+
+    def ipoll(self, timeout=-1, flags=0, /) -> Iterator[Tuple]:
+        """
+        Like :meth:`poll.poll`, but instead returns an iterator which yields a
+        `callee-owned tuple`. This function provides an efficient, allocation-free
+        way to poll on streams.
+
+        If *flags* is 1, one-shot behaviour for events is employed: streams for
+        which events happened will have their event masks automatically reset
+        (equivalent to ``poll.modify(obj, 0)``), so new events for such a stream
+        won't be processed until new mask is set with `poll.modify()`. This
+        behaviour is useful for asynchronous I/O schedulers.
+
+        Admonition:Difference to CPython
+           :class: attention
+
+           This function is a MicroPython extension.
+        """
+        ...