Update MicroPython to v1.28.0

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013-2025 Damien P. George
+Copyright (c) 2013-2026 Damien P. George
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

docs/library/index.rst

@@ -34,7 +34,9 @@ These libraries are not currently enabled in any CircuitPython build, but may be
    platform.rst
    re.rst
    select.rst
+   string.templatelib.rst
    sys.rst
+   weakref.rst
 
 Omitted ``string`` functions
 ----------------------------

docs/library/re.rst

@@ -54,6 +54,10 @@ Supported operators and special sequences are:
    Grouping. Each group is capturing (a substring it captures can be accessed
    with `match.group()` method).
 
+``(?:...)``
+   Non-capturing grouping. Each group is matched using the same rules as
+   regular grouping, but will not be part of the match object.
+
 ``\d``
    Matches digit. Equivalent to ``[0-9]``.
 
@@ -87,7 +91,6 @@ Supported operators and special sequences are:
 
 * counted repetitions (``{m,n}``)
 * named groups (``(?P<name>...)``)
-* non-capturing groups (``(?:...)``)
 * more advanced assertions (``\b``, ``\B``)
 * special character escapes like ``\r``, ``\n`` - use Python's own escaping
   instead

docs/library/select.rst

@@ -76,6 +76,9 @@ Methods
 
    In case of timeout, an empty list is returned.
 
+   Calling ``poll.poll`` is guaranteed to call pending callback functions
+   before entering the polling loop.
+
    .. admonition:: Difference to CPython
       :class: attention
 
@@ -93,6 +96,9 @@ Methods
    won't be processed until new mask is set with `poll.modify()`. This
    behaviour is useful for asynchronous I/O schedulers.
 
+   Calling ``poll.ipoll`` is guaranteed to call pending callback functions
+   before entering the polling loop.
+
    .. admonition:: Difference to CPython
       :class: attention
 

docs/library/string.templatelib.rst

@@ -0,0 +1,230 @@
+:mod:`string.templatelib` -- Template String Support
+====================================================
+
+.. module:: string.templatelib
+   :synopsis: PEP 750 template string support
+
+This module provides support for template strings (t-strings) as defined in
+`PEP 750 <https://peps.python.org/pep-0750/>`_. Template strings are created
+using the ``t`` prefix and provide access to both the literal string parts and
+interpolated values before they are combined.
+
+**Availability:** template strings require ``MICROPY_PY_TSTRINGS`` to be enabled
+at compile time. They are enabled by default at the full feature level, which
+includes the alif, mimxrt and samd (SAMD51 only) ports, the unix coverage variant
+and the webassembly pyscript variant.
+
+Classes
+-------
+
+.. class:: Template(*args)
+
+   Represents a template string. Template objects are typically created by
+   t-string syntax (``t"..."``) but can also be constructed directly using
+   the constructor.
+
+   .. attribute:: strings
+
+      A tuple of string literals that appear between interpolations.
+
+   .. attribute:: interpolations
+
+      A tuple of :class:`Interpolation` objects representing the interpolated
+      expressions.
+
+   .. attribute:: values
+
+      A read-only property that returns a tuple containing the ``value``
+      attribute from each interpolation in the template.
+
+   .. method:: __iter__()
+
+      Iterate over the template contents, yielding string parts and
+      :class:`Interpolation` objects in the order they appear. Empty strings
+      are omitted.
+
+   .. method:: __add__(other)
+
+      Concatenate two templates. Returns a new :class:`Template` combining
+      the strings and interpolations from both templates.
+
+      :raises TypeError: if *other* is not a :class:`Template`
+
+      Template concatenation with ``str`` is prohibited to avoid ambiguity
+      about whether the string should be treated as a literal or interpolation::
+
+         t1 = t"Hello "
+         t2 = t"World"
+         result = t1 + t2  # Valid
+
+         # TypeError: cannot concatenate str to Template
+         result = t1 + "World"
+
+.. class:: Interpolation(value, expression='', conversion=None, format_spec='')
+
+   Represents an interpolated expression within a template string. All
+   arguments can be passed as keyword arguments.
+
+   .. attribute:: value
+
+      The evaluated value of the interpolated expression.
+
+   .. attribute:: expression
+
+      The string representation of the expression as it appeared in the
+      template string.
+
+   .. attribute:: conversion
+
+      The conversion specifier (``'s'`` or ``'r'``) if present, otherwise ``None``.
+      Note that MicroPython does not support the ``'a'`` conversion.
+
+   .. attribute:: format_spec
+
+      The format specification string if present, otherwise an empty string.
+
+Template String Syntax
+----------------------
+
+Template strings use the same syntax as f-strings but with a ``t`` prefix::
+
+    name = "World"
+    template = t"Hello {name}!"
+
+    # Access template components
+    print(template.strings)        # ('Hello ', '!')
+    print(template.values)         # ('World',)
+    print(template.interpolations[0].expression)  # 'name'
+
+Conversion Specifiers
+~~~~~~~~~~~~~~~~~~~~~
+
+Template strings store conversion specifiers as metadata. Unlike f-strings,
+the conversion is not applied automatically::
+
+    value = "test"
+    t = t"{value!r}"
+    # t.interpolations[0].value == "test" (not repr(value))
+    # t.interpolations[0].conversion == "r"
+
+Processing code must explicitly apply conversions when needed.
+
+Format Specifications
+~~~~~~~~~~~~~~~~~~~~~
+
+Format specifications are stored as metadata in the ``Interpolation`` object.
+Unlike f-strings, formatting is not applied automatically::
+
+    pi = 3.14159
+    t = t"{pi:.2f}"
+    # t.interpolations[0].value == 3.14159 (not formatted)
+    # t.interpolations[0].format_spec == ".2f"
+
+Per PEP 750, processing code is not required to use format specifications, but
+when present they should be respected and match f-string behavior where possible.
+
+Debug Format
+~~~~~~~~~~~~
+
+The debug format ``{expr=}`` is supported::
+
+    x = 42
+    t = t"{x=}"
+    # t.strings == ("x=", "")
+    # t.interpolations[0].expression == "x"
+    # t.interpolations[0].conversion == "r"
+
+.. admonition:: Important
+   :class: attention
+
+   As per PEP 750, unlike f-strings, template strings do not automatically
+   apply conversions or format specifications. This is by design to allow
+   processing code to control how these are handled. Processing code must
+   explicitly handle these attributes.
+
+   MicroPython does not provide the ``format()`` built-in function. Use
+   string formatting methods like ``str.format()`` instead.
+
+Example Usage
+-------------
+
+Basic processing without format support::
+
+    def simple_process(template):
+        """Simple template processing"""
+        parts = []
+        for item in template:
+            if isinstance(item, str):
+                parts.append(item)
+            else:
+                parts.append(str(item.value))
+        return "".join(parts)
+
+Processing template with format support::
+
+    from string.templatelib import Template, Interpolation
+
+    def convert(value, conversion):
+        """Apply conversion specifier to value"""
+        if conversion == "r":
+            return repr(value)
+        elif conversion == "s":
+            return str(value)
+        return value
+
+    def process_template(template):
+        """Process template with conversion and format support"""
+        result = []
+        for part in template:
+            if isinstance(part, str):
+                result.append(part)
+            else:  # Interpolation
+                value = convert(part.value, part.conversion)
+                if part.format_spec:
+                    # Apply format specification using str.format
+                    value = ("{:" + part.format_spec + "}").format(value)
+                else:
+                    value = str(value)
+                result.append(value)
+        return "".join(result)
+
+    pi = 3.14159
+    name = "Alice"
+    t = t"{name!r}: {pi:.2f}"
+    print(process_template(t))
+    # Output: "'Alice': 3.14"
+
+    # Other format specifications work too
+    value = 42
+    print(process_template(t"{value:>10}"))  # "        42"
+    print(process_template(t"{value:04d}"))  # "0042"
+
+HTML escaping example::
+
+    def html_escape(value):
+        """Escape HTML special characters"""
+        if not isinstance(value, str):
+            value = str(value)
+        return value.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+    def safe_html(template):
+        """Convert template to HTML-safe string"""
+        result = []
+        for part in template:
+            if isinstance(part, str):
+                result.append(part)
+            else:
+                result.append(html_escape(part.value))
+        return "".join(result)
+
+    user_input = "<script>alert('xss')</script>"
+    t = t"User said: {user_input}"
+    print(safe_html(t))
+    # Output: "User said: &lt;script&gt;alert('xss')&lt;/script&gt;"
+
+See Also
+--------
+
+* `PEP 750 <https://peps.python.org/pep-0750/>`_ - Template Strings specification
+* :ref:`python:formatstrings` - Format string syntax
+* `Formatted string literals <https://docs.python.org/3/reference/lexical_analysis.html#f-strings>`_ - f-strings in Python

docs/library/weakref.rst

@@ -0,0 +1,78 @@
+:mod:`weakref` -- Python object lifetime management
+===================================================
+
+.. module:: weakref
+   :synopsis: Create weak references to Python objects
+
+|see_cpython_module| :mod:`python:weakref`.
+
+This module allows creation of weak references to Python objects.  A weak reference
+is a non-traceable reference to a heap-allocated Python object, so the garbage
+collector can still reclaim the object even though the weak reference refers to it.
+
+Python callbacks can be registered to be called when an object is reclaimed by the
+garbage collector.  This provides a safe way to clean up when objects are no longer
+needed.
+
+**Availability:** the weakref module requires ``MICROPY_PY_WEAKREF`` to be enabled
+at compile time.  It is enabled on the unix coverage variant and the webassembly
+pyscript variant.
+
+ref objects
+-----------
+
+A ref object is the simplest way to make a weak reference.
+
+.. class:: ref(object [, callback], /)
+
+   Return a weak reference to the given *object*.
+
+   If *callback* is given and is not ``None`` then, when *object* is reclaimed
+   by the garbage collector and if the weak reference object is still alive, the
+   *callback* will be called.  The *callback* will be passed the weak reference
+   object as its single argument.
+
+.. method:: ref.__call__()
+
+   Calling the weak reference object will return its referenced object if that
+   object is still alive.  Otherwise ``None`` will be returned.
+
+finalize objects
+----------------
+
+A finalize object is an extended version of a ref object that is more convenient to
+use, and allows more control over the callback.
+
+.. class:: finalize(object, callback, /, *args, **kwargs)
+
+   Return a weak reference to the given *object*.  In contrast to *weakref.ref*
+   objects, finalize objects are held onto internally and will not be collected until
+   *object* is collected.
+
+   A finalize object starts off alive.  It transitions to the dead state when the
+   finalize object is called, either explicitly or when *object* is collected.  It also
+   transitions to dead if the `finalize.detach()` method is called.
+
+   When *object* is reclaimed by the garbage collector (or the finalize object is
+   explicitly called by user code) and the finalize object is still in the alive state,
+   the *callback* will be called.  The *callback* will be passed arguments as:
+   ``callback(*args, **kwargs)``.
+
+.. method:: finalize.__call__()
+
+   If the finalize object is alive then it transitions to the dead state and returns
+   the value of ``callback(*args, **kwargs)``.  Otherwise ``None`` will be returned.
+
+.. method:: finalize.alive
+
+   Read-only boolean attribute that indicates if the finalizer is in the alive state.
+
+.. method:: finalize.peek()
+
+   If the finalize object is alive then return ``(object, callback, args, kwargs)``.
+   Otherwise return ``None``.
+
+.. method:: finalize.detach()
+
+   If the finalize object is alive then it transitions to the dead state and returns
+   ``(object, callback, args, kwargs)``. Otherwise ``None`` will be returned.

extmod/modos.c

@@ -145,6 +145,21 @@ static mp_obj_t mp_os_dupterm_notify(mp_obj_t obj_in) {
 static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_dupterm_notify_obj, mp_os_dupterm_notify);
 #endif
 
+#if MICROPY_PY_OS_URANDOM
+// This wraps the port-specific mp_hal_get_random(), which is usually defined in mphalport.c.
+static mp_obj_t mp_os_urandom(mp_obj_t num) {
+    mp_int_t n = mp_obj_get_int(num);
+    if (n < 0) {
+        mp_raise_ValueError(NULL);
+    }
+    vstr_t vstr;
+    vstr_init_len(&vstr, n);
+    mp_hal_get_random(n, (uint8_t *)vstr.buf);
+    return mp_obj_new_bytes_from_vstr(&vstr);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_urandom_obj, mp_os_urandom);
+#endif
+
 static const mp_rom_map_elem_t os_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_os) },
 

extmod/modselect.c

@@ -344,6 +344,8 @@ static mp_uint_t poll_set_poll_until_ready_or_timeout(poll_set_t *poll_set, size
     mp_uint_t start_ticks = mp_hal_ticks_ms();
     bool has_timeout = timeout != (mp_uint_t)-1;
 
+    mp_handle_pending(true);
+
     #if MICROPY_PY_SELECT_POSIX_OPTIMISATIONS
 
     for (;;) {