Merge remote-tracking branch 'origin/main' into main

Author: weblate

.git-blame-ignore-revs

@@ -1,3 +1,6 @@
+# tools/gen-cpydiff.py: Fix formatting of doc strings for new Black.
+0f78c36c5aa458a954eed39a46942209107a553e
+
 # tests/run-tests.py: Reformat with Black.
 2a38d7103672580882fb621a5b76e8d26805d593
 

docs/library/builtins.rst

@@ -182,10 +182,6 @@ Exceptions
 
 .. exception:: OSError
 
-    |see_cpython| :py:class:`cpython:OSError`. CircuitPython doesn't implement the ``errno``
-    attribute, instead use the standard way to access exception arguments:
-    ``exc.args[0]``.
-
 .. exception:: RuntimeError
 
 .. exception:: ReloadException

docs/library/uasyncio.rst

@@ -214,6 +214,14 @@ TCP stream connections
 
     This is a coroutine.
 
+.. method:: Stream.readinto(buf)
+
+    Read up to n bytes into *buf* with n being equal to the length of *buf*.
+
+    Return the number of bytes read into *buf*.
+
+    This is a coroutine, and a MicroPython extension.
+
 .. method:: Stream.readline()
 
     Read a line and return it.

docs/library/uctypes.rst

@@ -247,7 +247,7 @@ Module contents
 
 .. data:: VOID
 
-   ``VOID`` is an alias for ``UINT8``, and is provided to conviniently define
+   ``VOID`` is an alias for ``UINT8``, and is provided to conveniently define
    C's void pointers: ``(uctypes.PTR, uctypes.VOID)``.
 
 .. data:: PTR

docs/library/uheapq.rst

@@ -8,9 +8,11 @@
 
 |see_cpython_module| :mod:`cpython:heapq`.
 
-This module implements the heap queue algorithm.
+This module implements the
+`min heap queue algorithm <https://en.wikipedia.org/wiki/Heap_%28data_structure%29>`_.
 
-A heap queue is simply a list that has its elements stored in a certain way.
+A heap queue is essentially a list that has its elements stored in such a way
+that the first item of the list is always the smallest.
 
 Functions
 ---------
@@ -21,8 +23,10 @@ Functions
 
 .. function:: heappop(heap)
 
-   Pop the first item from the ``heap``, and return it.  Raises IndexError if
-   heap is empty.
+   Pop the first item from the ``heap``, and return it.  Raise ``IndexError`` if
+   ``heap`` is empty.
+
+   The returned item will be the smallest item in the ``heap``.
 
 .. function:: heapify(x)
 

docs/library/uselect.rst

@@ -89,11 +89,11 @@ Methods
    ``callee-owned tuples``. This function provides efficient, allocation-free
    way to poll on streams.
 
-   If *flags* is 1, one-shot behavior for events is employed: streams for
+   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
-   behavior is useful for asynchronous I/O schedulers.
+   behaviour is useful for asynchronous I/O schedulers.
 
    .. admonition:: Difference to CPython
       :class: attention

extmod/moduasyncio.c

@@ -31,12 +31,19 @@
 
 #if MICROPY_PY_UASYNCIO
 
+#define TASK_STATE_RUNNING_NOT_WAITED_ON (mp_const_true)
+#define TASK_STATE_DONE_NOT_WAITED_ON (mp_const_none)
+#define TASK_STATE_DONE_WAS_WAITED_ON (mp_const_false)
+
+#define TASK_IS_DONE(task) ( \
+    (task)->state == TASK_STATE_DONE_NOT_WAITED_ON \
+    || (task)->state == TASK_STATE_DONE_WAS_WAITED_ON)
+
 typedef struct _mp_obj_task_t {
     mp_pairheap_t pairheap;
     mp_obj_t coro;
     mp_obj_t data;
-    mp_obj_t waiting;
-
+    mp_obj_t state;
     mp_obj_t ph_key;
 } mp_obj_task_t;
 
@@ -146,9 +153,6 @@ STATIC const mp_obj_type_t task_queue_type = {
 /******************************************************************************/
 // Task class
 
-// For efficiency, the task object is stored to the coro entry when the task is done.
-#define TASK_IS_DONE(task) ((task)->coro == MP_OBJ_FROM_PTR(task))
-
 // This is the core uasyncio context with cur_task, _task_queue and CancelledError.
 STATIC mp_obj_t uasyncio_context = MP_OBJ_NULL;
 
@@ -159,7 +163,7 @@ STATIC mp_obj_t task_make_new(const mp_obj_type_t *type, size_t n_args, const mp
     mp_pairheap_init_node(task_lt, &self->pairheap);
     self->coro = args[0];
     self->data = mp_const_none;
-    self->waiting = mp_const_none;
+    self->state = TASK_STATE_RUNNING_NOT_WAITED_ON;
     self->ph_key = MP_OBJ_NEW_SMALL_INT(0);
     if (n_args == 2) {
         uasyncio_context = args[1];
@@ -218,24 +222,6 @@ STATIC mp_obj_t task_cancel(mp_obj_t self_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(task_cancel_obj, task_cancel);
 
-STATIC mp_obj_t task_throw(mp_obj_t self_in, mp_obj_t value_in) {
-    // This task raised an exception which was uncaught; handle that now.
-    mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
-    // Set the data because it was cleared by the main scheduling loop.
-    self->data = value_in;
-    if (self->waiting == mp_const_none) {
-        // Nothing await'ed on the task so call the exception handler.
-        mp_obj_t _exc_context = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR__exc_context));
-        mp_obj_dict_store(_exc_context, MP_OBJ_NEW_QSTR(MP_QSTR_exception), value_in);
-        mp_obj_dict_store(_exc_context, MP_OBJ_NEW_QSTR(MP_QSTR_future), self_in);
-        mp_obj_t Loop = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_Loop));
-        mp_obj_t call_exception_handler = mp_load_attr(Loop, MP_QSTR_call_exception_handler);
-        mp_call_function_1(call_exception_handler, _exc_context);
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(task_throw_obj, task_throw);
-
 STATIC void task_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
     if (dest[0] == MP_OBJ_NULL) {
@@ -244,32 +230,24 @@ STATIC void task_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
             dest[0] = self->coro;
         } else if (attr == MP_QSTR_data) {
             dest[0] = self->data;
-        } else if (attr == MP_QSTR_waiting) {
-            if (self->waiting != mp_const_none && self->waiting != mp_const_false) {
-                dest[0] = self->waiting;
-            }
+        } else if (attr == MP_QSTR_state) {
+            dest[0] = self->state;
         } else if (attr == MP_QSTR_done) {
             dest[0] = MP_OBJ_FROM_PTR(&task_done_obj);
             dest[1] = self_in;
         } else if (attr == MP_QSTR_cancel) {
             dest[0] = MP_OBJ_FROM_PTR(&task_cancel_obj);
             dest[1] = self_in;
-        } else if (attr == MP_QSTR_throw) {
-            dest[0] = MP_OBJ_FROM_PTR(&task_throw_obj);
-            dest[1] = self_in;
         } else if (attr == MP_QSTR_ph_key) {
             dest[0] = self->ph_key;
         }
     } else if (dest[1] != MP_OBJ_NULL) {
         // Store
-        if (attr == MP_QSTR_coro) {
-            self->coro = dest[1];
-            dest[0] = MP_OBJ_NULL;
-        } else if (attr == MP_QSTR_data) {
+        if (attr == MP_QSTR_data) {
             self->data = dest[1];
             dest[0] = MP_OBJ_NULL;
-        } else if (attr == MP_QSTR_waiting) {
-            self->waiting = dest[1];
+        } else if (attr == MP_QSTR_state) {
+            self->state = dest[1];
             dest[0] = MP_OBJ_NULL;
         }
     }
@@ -278,15 +256,12 @@ STATIC void task_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 STATIC mp_obj_t task_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
     (void)iter_buf;
     mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->waiting == mp_const_none) {
-        // The is the first access of the "waiting" entry.
-        if (TASK_IS_DONE(self)) {
-            // Signal that the completed-task has been await'ed on.
-            self->waiting = mp_const_false;
-        } else {
-            // Lazily allocate the waiting queue.
-            self->waiting = task_queue_make_new(&task_queue_type, 0, 0, NULL);
-        }
+    if (TASK_IS_DONE(self)) {
+        // Signal that the completed-task has been await'ed on.
+        self->state = TASK_STATE_DONE_WAS_WAITED_ON;
+    } else if (self->state == TASK_STATE_RUNNING_NOT_WAITED_ON) {
+        // Allocate the waiting queue.
+        self->state = task_queue_make_new(&task_queue_type, 0, 0, NULL);
     }
     return self_in;
 }
@@ -299,7 +274,7 @@ STATIC mp_obj_t task_iternext(mp_obj_t self_in) {
     } else {
         // Put calling task on waiting queue.
         mp_obj_t cur_task = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_cur_task));
-        mp_obj_t args[2] = { self->waiting, cur_task };
+        mp_obj_t args[2] = { self->state, cur_task };
         task_queue_push_sorted(2, args);
         // Set calling task's data to this task that it waits on, to double-link it.
         ((mp_obj_task_t *)MP_OBJ_TO_PTR(cur_task))->data = self_in;