Oct 3, 2026

fix: Improve Dial rendering and themingPython · 111 + / 20 −

Introduces 9 new declarations in panel/widgets/indicators.py.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

panel/widgets/indicators.py ↗ · 3 files

@@ -705,17 +705,98 @@ def __init__(self, **params):     def _update_value_bounds(self):         self.param.value.bounds = self.bounds +    @property+    def _unfilled_color(self) -> str:+        # Without an outline, whitesmoke is indistinguishable from a white page.+        if self.unfilled_color:+            return self.unfilled_color+        return '#424242' if config.theme == 'dark' else '#e8e8e8'++    def _angles(self) -> tuple[float, float, float]:+        start = (np.radians(360-self.start_angle) - pi % (2*pi)) + pi+        end = (np.radians(360-self.end_angle) - pi % (2*pi)) + pi+        distance = (abs(end-start) % (pi*2))+        if end>start:+            distance = (pi*2)-distance+        return start, end, distance++    def _size(self) -> tuple[int, int]:+        height = self.height or self.width or 250+        return self.width or height, height++    def _font_sizes(self) -> tuple[str, str, str]:+        scale = (self._size()[1]/400)+        title_size = self.title_size if self.title_size else '%spt' % (scale*32)+        value_size = self.value_size if self.value_size else '%spt' % (scale*48)+        tick_size = self.tick_size if self.tick_size else '%spt' % (scale*18)+        return title_size, value_size, tick_size++    @staticmethod+    def _font_px(size: str) -> float:+        # Only reserves layout space, so a rough guess for unknown units is fine.+        try:

BUG: fix repr of longdouble values outside float64 range (GH#17809)Python · 38 + / 10 −

Introduces 2 new declarations in pandas/io/formats/format.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

pandas/io/formats/format.py ↗ · 3 files

@@ -1373,6 +1374,26 @@ def formatter(value):          return formatter +    def _fixed_width_format(self, kind: Literal["f", "e"]) -> Callable:+        # np.longdouble.__format__ casts to float64, which turns values outside+        # its range into 0 or inf, so format those with numpy (GH#17809)+        if (+            self.values.dtype == np.longdouble+            and np.finfo(np.longdouble).precision > np.finfo(np.float64).precision+        ):+            return partial(+                _format_longdouble,+                kind=kind,+                digits=self.digits,+                leading_space=self.leading_space,+            )++        if self.leading_space is True:+            fmt_str = "{value: .{digits:d}{kind}}"+        else:+            fmt_str = "{value:.{digits:d}{kind}}"+        return partial(fmt_str.format, digits=self.digits, kind=kind)+     def get_result_as_array(self) -> np.ndarray:         """         Returns the float values converted into strings using

model: add support for clef decision model (text-only)C++ · 996 + / 16 −

Introduces 11 new declarations in src/models/clef.cpp.

Adds new runtime rather than adjusting what was there. Read the linked PR for the surrounding test context.

src/models/clef.cpp ↗ · 24 files

@@ -0,0 +1,616 @@+#include "models.h"++#include "llama-ext.h"++#include <cmath>++void llama_model_clef::load_arch_hparams(llama_model_loader & ml) {+    llama_model_qwen35::load_arch_hparams(ml);++    ml.get_key(LLM_KV_DECISION_ROUTING_BLOCK_COUNT, n_layer_routing);+    ml.get_key(LLM_KV_DECISION_BLOCK_COUNT,         n_layer_joint);+    ml.get_key(LLM_KV_DECISION_HEAD_COUNT,          n_head_decision);++    if (n_head_decision == 0 || n_layer_routing > LLAMA_MAX_LAYERS || n_layer_joint > LLAMA_MAX_LAYERS) {+        throw std::runtime_error("invalid size of the decision head");+    }++    // used by the head+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_EPS, hparams.f_norm_eps);++    // the output is one score per token, see llama_batch_ext_set_decision_order()+    hparams.n_embd_out_impl = 1;+}++void llama_model_clef::load_arch_tensors(llama_model_loader & ml) {+    llama_model_qwen35::load_arch_tensors(ml);++    LLAMA_LOAD_LOCALS;++    const auto * w_memory = ml.get_weight(tn(LLM_TENSOR_DECISION_PROJ_MEMORY, "weight").str().c_str());+    const auto * w_ffn    = ml.get_weight(tn(LLM_TENSOR_DEC_FFN_UP, "weight", 0).str().c_str());+    if (w_memory == nullptr || w_ffn == nullptr) {+        throw std::runtime_error("the decision head is missing");

REV: Revert changes to broadcasting of arraysPython · 28 + / 36 −

Introduces 1 new declaration in numpy/lib/_stride_tricks_impl.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

numpy/lib/_stride_tricks_impl.py ↗ · 5 files

@@ -639,26 +641,16 @@ def broadcast_arrays(*args, subok=False):             [5, 5, 5]])]      """-    arrays = [np.asarray(_m) for _m in args]-    if 0 < len(arrays) < 65:-        # Fast path: a single nditer handles up to NPY_MAXARGS (64) operands-        # (but requires at least one, hence the ``0 <``).-        views = np.nditer(arrays, flags=_BROADCAST_ITER_FLAGS, order='C').itviews-    else:-        shape = _broadcast_shape(*arrays)-        # Create the views in chunks of at most NPY_MAXARGS operands. The-        # views are read-only, exactly like the ones returned by the fast path.-        views = []-        for pos in range(0, len(arrays), 64):-            it = np.nditer(arrays[pos:pos + 64], flags=_BROADCAST_ITER_FLAGS,-                           op_flags=['readonly'], itershape=shape, order='C')-            views.extend(it.itviews)-        views = tuple(views)--    if subok:-        # Only ndarray subclasses need to be viewed as the input type; other-        # inputs were converted to base-class arrays above.-        views = tuple(_maybe_view_as_subclass(array, view)-                      if isinstance(array, np.ndarray) else view-                      for array, view in zip(args, views))-    return views+    # nditer is not used here to avoid the limit of 64 arrays.+    # Otherwise, something like the following one-liner would suffice:+    # return np.nditer(args, flags=['multi_index', 'zerosize_ok'],+    #                  order='C').itviews++    args = [np.array(_m, copy=None, subok=subok) for _m in args]+

Improve suggestion for lifetime preceding type in genericsRust · 65 + / 14 −

Introduces 2 new declarations in compiler/rustc_parse/src/parser/diagnostics.rs.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

compiler/rustc_parse/src/parser/diagnostics.rs ↗ · 7 files

@@ -2286,6 +2286,44 @@ impl<'a> Parser<'a> {         }     } +    /// Handle encountering a lifetime in a generic argument list that is not+    /// followed by a `,` or `>`.+    /// We emit an error and check if the lifetime is followed by a type+    /// in, e.g. `Foo<'a T>`.+    /// In this case, it is likely the user meant either `Foo<&'a T>` or `Foo<'a, T>`.+    /// We give both suggestions, then emit an error. Note that we do not try to recover,+    /// since we cannot know which of the two suggestions is correct and emitting either+    /// of the two types could cause confusing errors further on.+    pub(super) fn handle_lifetime_arg_preceding_type(&mut self, span: Span) -> PResult<'a, ()> {+        let snapshot = self.create_snapshot_for_diagnostic();+        let (mutbl, ty) = self.parse_ref_ty_no_leading_ampersand();+        self.restore_snapshot(snapshot);+        if ty.is_none() {+            // The lifetime is not followed by a type, do nothing.+            return Ok(());+        }+        // If we find `'a mut T`, suggesting to add a comma is wrong.+        let suggest_comma = mutbl.is_not();+        // Add `>` to the list of expected tokens.+        self.check(exp!(Gt));+        let mut err = self.unexpected().unwrap_err();+        err.span_suggestion_verbose(+            span.shrink_to_lo(),+            "you might have meant to write a reference type here",+            "&",+            Applicability::MaybeIncorrect,+        );+        if suggest_comma {+            err.span_suggestion_verbose(+                span.shrink_to_hi(),