DO NOT MERGE: Wifi ap debug

.github/actions/deps/external/action.yml

@@ -29,16 +29,11 @@ runs:
         release: '15.2.Rel1'
 
     # espressif
-    - name: Get espressif toolchain
-      if: inputs.port == 'espressif'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y ninja-build
-      shell: bash
     - name: Install IDF tools
       if: inputs.port == 'espressif'
       run: |
         $IDF_PATH/install.sh
+        $IDF_PATH/tools/idf_tools.py install ninja
         rm -rf $IDF_TOOLS_PATH/dist
       shell: bash
     - name: Set environment

.github/actions/deps/ports/espressif/action.yml

@@ -30,7 +30,7 @@ runs:
       uses: actions/cache@v5
       with:
         path: ${{ env.IDF_TOOLS_PATH }}
-        key: ${{ runner.os }}-${{ env.pythonLocation }}-tools-idf-${{ steps.idf-commit.outputs.commit }}
+        key: ${{ runner.os }}-${{ env.pythonLocation }}-tools-idf-${{ steps.idf-commit.outputs.commit }}-20260911
 
     - name: Initialize IDF submodules
       run: git submodule update --init --depth=1 --recursive $IDF_PATH

.github/workflows/build.yml

@@ -22,6 +22,7 @@ jobs:
     runs-on: ubuntu-24.04
     outputs:
       docs: ${{ steps.set-matrix.outputs.docs }}
+      zephyr-tests: ${{ steps.set-matrix.outputs.zephyr-tests }}
       ports: ${{ steps.set-matrix.outputs.ports }}
       cp-version: ${{ steps.set-up-submodules.outputs.version }}
     steps:
@@ -102,6 +103,7 @@ jobs:
 
   zephyr-tests:
     needs: scheduler
+    if: needs.scheduler.outputs.zephyr-tests == 'True'
     uses: ./.github/workflows/run-zephyr-tests.yml
     with:
       cp-version: ${{ needs.scheduler.outputs.cp-version }}

.github/workflows/run-zephyr-tests.yml

@@ -10,8 +10,22 @@ on:
 jobs:
   zephyr:
     runs-on: ubuntu-24.04
+    name: ${{ matrix.shard }}
     strategy:
       fail-fast: false
+      # One job per board family, so the bsim suites, which take the longest, run
+      # side by side instead of after each other.
+      matrix:
+        include:
+          - shard: native_sim
+            boards: native_native_sim native_native_sim_asan
+            pytest_args: tests/ --ignore=tests/bsim
+          - shard: nrf5340bsim
+            boards: native_nrf5340bsim
+            pytest_args: tests/bsim -k native_nrf5340bsim
+          - shard: nrf54lm20bsim
+            boards: native_nrf54lm20bsim
+            pytest_args: tests/bsim -k native_nrf54lm20bsim
     env:
       CP_VERSION: ${{ inputs.cp-version }}
     steps:
@@ -36,14 +50,9 @@ jobs:
           target: zephyr-cp
       - name: Set up external
         uses: ./.github/actions/deps/external
-      - name: Build native sim target
-        run: make -C ports/zephyr-cp -j$(nproc) BOARD=native_native_sim
       - name: Build bsim
+        if: contains(matrix.shard, 'bsim')
         run: make -j $(nproc) everything
         working-directory: ports/zephyr-cp/tools/bsim
-      - name: Build native_nrf5340bsim
-        run: make -C ports/zephyr-cp -j$(nproc) BOARD=native_nrf5340bsim
-      - name: Build native_nrf54lm20bsim
-        run: make -C ports/zephyr-cp -j$(nproc) BOARD=native_nrf54lm20bsim
       - name: Run Zephyr tests
-        run: make -C ports/zephyr-cp test
+        run: make -C ports/zephyr-cp test TEST_BOARDS="${{ matrix.boards }}" PYTEST_ARGS="${{ matrix.pytest_args }}"

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

conf.py

@@ -197,6 +197,7 @@ def autoapi_prepare_jinja_env(jinja_env):
     "docs/README.md",
     "AGENTS.md",
     "**/AGENTS.md",
+    "docs/library/weakref.rst",
 ]
 
 # The reST default role (used for this markup: `text`) to use for all

docs/library/index.rst

@@ -34,6 +34,7 @@ These libraries are not currently enabled in any CircuitPython build, but may be
    platform.rst
    re.rst
    select.rst
+   string.templatelib.rst
    sys.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,225 @@
+: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.
+
+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