Oct 15, 2026 – Oct 21, 2026

BUG: MultiIndex.rename rejects the name keyword (GH#33778)Python · 90 + / 3 −

Introduces 4 new declarations in pandas/core/indexes/multi.py.

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

pandas/core/indexes/multi.py ↗ · 4 files

@@ -5013,9 +5014,95 @@ def isin(self, values, level=None) -> npt.NDArray[np.bool_]:                 return np.zeros(len(levs), dtype=np.bool_)             return levs.isin(values) -    # error: Incompatible types in assignment (expression has type overloaded function,-    # base class "Index" defined the type as "Callable[[Index, Any, bool], Any]")-    rename = Index.set_names  # type: ignore[assignment]+    @overload+    def rename(+        self,+        name: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        *,+        names: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        level: Hashable | Sequence[Hashable] | None = ...,+        inplace: Literal[False] = ...,+    ) -> Self: ...++    @overload+    def rename(+        self,+        name: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        *,+        names: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        level: Hashable | Sequence[Hashable] | None = ...,+        inplace: Literal[True],+    ) -> None: ...++    @overload+    def rename(+        self,+        name: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        *,+        names: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        level: Hashable | Sequence[Hashable] | None = ...,

Turbopack: propagate late partial namespace provenance to passthrough targetsRust · 277 + / 6 −

Introduces 25 new declarations in turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs.

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

turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs ↗ · 8 files

@@ -513,3 +520,267 @@ mod tests {         assert!(matches!(usage, ModuleExportUsageInfo::All));     } }++#[cfg(test)]+mod graph_tests {+    use anyhow::Result;+    use rustc_hash::FxHashMap;+    use turbo_rcstr::{RcStr, rcstr};+    use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};+    use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};+    use turbo_tasks_fs::{FileSystem, FileSystemPath, VirtualFileSystem};++    use super::compute_binding_usage_info;+    use crate::{+        asset::{Asset, AssetContent},+        ident::AssetIdent,+        module::{Module, ModuleSideEffects},+        module_graph::{+            GraphEntries, ModuleGraph, SingleModuleGraph,+            chunk_group_info::{ChunkGroupEntry, EntryHeuristics},+        },+        reference::{ModuleReference, ModuleReferences, SingleChunkableModuleReference},+        resolve::ExportUsage,+    };++    /// Module name -> outgoing edges `(target name, export usage of the edge)`, in reference order.+    type Edges = Vec<(RcStr, Vec<(RcStr, ExportUsage)>)>;++    #[turbo_tasks::value(shared)]+    struct UsageTestRepo {+        edges: FxHashMap<RcStr, Vec<(RcStr, ExportUsage)>>,+    }

Fix extensionless Google font URLs in both bundlersRust · 145 + / 8 −

Introduces 3 new declarations in crates/next-core/src/next_font/google/mod.rs.

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

crates/next-core/src/next_font/google/mod.rs ↗ · 9 files

@@ -794,3 +830,104 @@ async fn get_mock_stylesheet(         }     } }++#[cfg(test)]+mod tests {+    use super::{+        FontFile, NextFontGoogleFontFileOptions, find_font_files_in_css,+        font_file_options_from_query_map, font_file_options_to_query,+    };++    #[test]+    fn font_extensions() {+        for (url, format, ext) in [+            (+                "https://fonts.gstatic.com/l/font?kit=a=b&skey=c&v=v20",+                "format('woff2')",+                "woff2",+            ),+            (+                "https://fonts.gstatic.com/l/font?kit=a%2Bb&skey=c",+                "format(\"woff\")",+                "woff",+            ),+            (+                "https://fonts.gstatic.com/l/font",+                "format('truetype')",+                "ttf",+            ),+            (+                "https://fonts.gstatic.com/l/font",+                "format('opentype')",+                "otf",

BUG: str regex \w, \d, \s and \b only matching ASCII for pyarrow-backed stringsPython · 79 + / 44 −

Introduces 5 new declarations in pandas/core/arrays/_arrow_string_mixins.py.

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

pandas/core/arrays/_arrow_string_mixins.py ↗ · 5 files

@@ -64,48 +77,72 @@ def _has_unsupported_regex(pat: str | re.Pattern[str]) -> bool:          Returns         --------        bool-            Whether `pat` contains a lookahead or lookbehind.+        list[tuple[Any, Any]]+            The nodes of `pat`, or an empty list if Python's ``re`` cannot+            parse it.         """-        try:-            # error: Module "re" has no attribute "_parser"-            from re import _parser  # type: ignore[attr-defined]+        _parser = ArrowStringArrayMixin._re_parser()+        repeats = {_parser.MAX_REPEAT, _parser.MIN_REPEAT, _parser.POSSESSIVE_REPEAT} -            regex_parser = _parser.parse-        except Exception as err:-            raise type(err)(-                "Incompatible version for regex; you will need to upgrade pandas "-                "or downgrade Python"-            ) from err--        def has_unsupported_code(tokens):-            # For certain op codes we need to recurse.+        def walk(tokens):             for op_code, argument in tokens:-                if (-                    (-                        op_code == _parser.SUBPATTERN-                        and has_unsupported_code(argument[3])-                    )-                    or (-                        op_code == _parser.BRANCH

MIR move elimination [4/6]: MoveEliminationRust · 959 + / 36 −

Introduces 41 new declarations in compiler/rustc_mir_transform/src/move_elimination.rs.

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

compiler/rustc_mir_transform/src/move_elimination.rs ↗ · 36 files

@@ -0,0 +1,911 @@+//! Eliminates copies and moves by unifying MIR places whose allocation ranges+//! are disjoint.+//!+//! See RFC 3943 for the local-lifetime semantics that make this optimization+//! possible.+//!+//! # Motivation+//!+//! MIR building can insert a lot of redundant copies, and Rust code in general+//! often tends to move values around a lot. The result is a lot of assignments+//! of the form `dest = {move} src;` in MIR. MIR building for constants in+//! particular tends to create additional locals that are only used inside a+//! single block to shuffle a value around unnecessarily.+//!+//! Additionally, Rust constructs nested aggregates by repeatedly moving values+//! into fields. For example, a function may build an inner value in a local,+//! move it into an outer aggregate, then move that aggregate into the caller's+//! destination. If these intermediate source and destination places have+//! different addresses, each layer needs an actual copy or move of the bytes.+//!+//! LLVM cannot remove these copies when both the source and destination+//! addresses are observed because merging the allocations would be an+//! observable change: the program could see that two addresses which were+//! previously distinct have become the same. This pass removes the copies+//! earlier, while MIR still has the information needed to prove that the two+//! allocation ranges do not overlap.+//!+//! # Optimization+//!+//! The basis of this optimization is place unification. If the source and+//! destination of an assignment have the same address, then the assignment is a+//! no-op. The same idea applies to aggregate construction: if a field operand+//! is already located at the corresponding field of the destination, then the

turbo-tasks-backend: optimize aggregated updates outside of the lockRust · 285 + / 7 −

Introduces 17 new declarations in turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs.

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

turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs ↗ · 2 files

@@ -3525,3 +3584,222 @@ fn retry_loop(mut retry: u16, mut f: impl FnMut() -> ControlFlow<()>) -> Result<         }     } }++#[cfg(test)]+mod tests {+    use rustc_hash::{FxHashMap, FxHashSet};+    use turbo_tasks::{CellId, TaskId, TraitTypeId, ValueTypeId};++    use super::{AggregatedDataUpdate, sum_collectibles_update};+    use crate::data::{CellRef, CollectibleRef};++    /// Models the collectibles part of `AggregatedDataUpdate::apply`: applies `update` to the+    /// counts of an upper and returns the keys whose presence (count > 0) flipped, in order.+    fn apply(upper: &mut FxHashMap<u32, i32>, update: &[(u32, i32)]) -> Vec<u32> {+        let mut flips = Vec::new();+        for &(key, count) in update {+            let old = upper.get(&key).copied().unwrap_or(0);+            let new = old + count;+            if (old <= 0 && new > 0) || (old > 0 && new <= 0) {+                flips.push(key);+            }+            if new == 0 {+                upper.remove(&key);+            } else {+                upper.insert(key, new);+            }+        }+        flips+    }++    fn presence_changes(before: &FxHashMap<u32, i32>, after: &FxHashMap<u32, i32>) -> Vec<u32> {+        let mut keys: Vec<u32> = before

Add Support to maion-coder archC++ · 170 + / 2 −

Introduces 3 new declarations in src/models/maion-coder.cpp.

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

src/models/maion-coder.cpp ↗ · 9 files

@@ -0,0 +1,149 @@+#include "models.h"++void llama_model_maion_coder::load_arch_hparams(llama_model_loader & ml) {+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS,       hparams.f_norm_rms_eps);+    ml.get_key_or_arr(LLM_KV_EXPERT_FEED_FORWARD_LENGTH, hparams.n_ff_exp_arr, hparams.n_layer_all);+    ml.get_key(LLM_KV_INTERLEAVE_MOE_LAYER_STEP,         hparams.n_moe_layer_step);+    ml.get_key(LLM_KV_MOE_LATENT_SIZE,                   hparams.moe_latent_size);++    if (hparams.n_moe_layer_step == 0 || hparams.moe_latent_size == 0 || hparams.n_expert == 0) {+        throw std::runtime_error("maion-coder requires a positive MoE layer step, latent size and expert count");+    }++    ml.get_key(LLM_KV_ATTENTION_SLIDING_WINDOW, hparams.n_swa);+    uint32_t n_swa_layers = 0;+    ml.get_arr_n(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, n_swa_layers);+    if (hparams.n_swa == 0 || n_swa_layers != hparams.n_layer_all) {+        throw std::runtime_error("maion-coder requires a positive sliding window and a sliding window pattern for each layer");+    }+    ml.get_arr(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, hparams.is_swa_impl);+    hparams.rope_pattern = hparams.is_swa_impl;+    hparams.swa_type = LLAMA_SWA_TYPE_STANDARD;+    hparams.rope_freq_base_train_swa  = hparams.rope_freq_base_train;+    hparams.rope_freq_scale_train_swa = hparams.rope_freq_scale_train;++    type = LLM_TYPE_UNKNOWN;+}++void llama_model_maion_coder::load_arch_tensors(llama_model_loader &) {+    LLAMA_LOAD_LOCALS;++    const int64_t moe_n_embd = hparams.moe_latent_size;++    tok_embd    = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD,  "weight"), {n_embd, n_vocab}, 0);

Only disable the compiler on the offload path in AlignDevicesHookPython · 64 + / 58 −

Introduces 9 new declarations in src/accelerate/hooks.py.

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

src/accelerate/hooks.py ↗ · 2 files

@@ -356,76 +356,82 @@ def _maybe_get_fp16_statistics(self, name, value):         return None      @_compiler_disable-    def pre_forward(self, module, *args, **kwargs):-        if self.io_same_device:-            self.input_device = find_device([args, kwargs])-        if self.offload:-            self.tied_pointers_to_remove = set()+    def _onload_weights(self, module):+        self.tied_pointers_to_remove = set() -            for name, _ in named_module_tensors(-                module,-                include_buffers=self.offload_buffers,-                recurse=self.place_submodules,-                remove_non_persistent=True,+        for name, _ in named_module_tensors(+            module,+            include_buffers=self.offload_buffers,+            recurse=self.place_submodules,+            remove_non_persistent=True,+        ):+            value = self.weights_map[name]+            fp16_statistics = self._maybe_get_fp16_statistics(name, value)++            # In case we are using offloading with tied weights, we need to keep track of the offloaded weights+            # that are loaded on device at this point, as we will need to remove them as well from the dictionary+            # self.tied_params_map in order to allow to free memory.+            if name in self.tied_params_names and value.data_ptr() not in self.tied_params_map:+                self.tied_params_map[value.data_ptr()] = {}++            if (+                value is not None

models: Add Flint model (FlintForCausalLM)C++ · 234 + / 5 −

Introduces 3 new declarations in src/models/flint.cpp.

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

src/models/flint.cpp ↗ · 18 files

@@ -0,0 +1,194 @@+#include "models.h"++void llama_model_flint::load_arch_hparams(llama_model_loader & ml) {+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps);+    ml.get_key(LLM_KV_LEADING_DENSE_BLOCK_COUNT,   hparams.n_layer_dense_lead);+    ml.get_key_or_arr(LLM_KV_EXPERT_FEED_FORWARD_LENGTH, hparams.n_ff_exp_arr, hparams.n_layer_all);+    ml.get_key(LLM_KV_EXPERT_SHARED_COUNT,         hparams.n_expert_shared);+    ml.get_key(LLM_KV_EXPERT_WEIGHTS_SCALE,        hparams.expert_weights_scale, false);+    ml.get_key(LLM_KV_EXPERT_WEIGHTS_NORM,         hparams.expert_weights_norm);+    ml.get_key(LLM_KV_EXPERT_GATING_FUNC,          hparams.expert_gating_func);++    ml.get_key(LLM_KV_EXPERT_SHARED_FEED_FORWARD_LENGTH, hparams.n_ff_shexp);+    ml.get_arr(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, hparams.is_swa_impl);+    ml.get_arr(LLM_KV_ATTENTION_ROPE_PATTERN, hparams.rope_pattern);+    ml.get_key(LLM_KV_ATTENTION_SLIDING_WINDOW, hparams.n_swa);+    hparams.swa_type = LLAMA_SWA_TYPE_STANDARD;+    type = LLM_TYPE_UNKNOWN;+}++void llama_model_flint::load_arch_tensors(llama_model_loader &) {+    LLAMA_LOAD_LOCALS;++    const int64_t n_ff_exp        = hparams.n_ff_exp();++    tok_embd = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD, "weight"), {n_embd, n_vocab}, 0);++    output_norm = create_tensor(tn(LLM_TENSOR_OUTPUT_NORM, "weight"), {n_embd}, 0);+    output      = create_tensor(tn(LLM_TENSOR_OUTPUT,      "weight"), {n_embd, n_vocab}, 0);++    for (int i = 0; i < n_layer; ++i) {+        auto & layer = layers[i];++        layer.attn_norm = create_tensor(tn(LLM_TENSOR_ATTN_NORM, "weight", i), {n_embd}, 0);

Align non-recursive responses between cacher and etcdGo · 72 + / 167 −

Introduces 3 new declarations in staging/src/k8s.io/apiserver/pkg/storage/testing/watcher_tests.go.

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

staging/src/k8s.io/apiserver/pkg/storage/testing/watcher_tests.go ↗ · 9 files

@@ -1516,64 +1498,34 @@ func RunTestNamespaceScopedWatch(ctx context.Context, t *testing.T, store storag 			name:          "namespaced watch, non-recursive, request without name, request without namespace, without field selector", 			recursive:     false, 			fieldSelector: fields.Everything(),-			watchTests: func() []*testWatchStruct {-				if isWatchCache {-					return []*testWatchStruct{-						{baseNamespacedPod("t43-foo1", "t43-ns1"), true, watch.Added},-						{baseNamespacedPod("t43-foo2", "t43-ns2"), true, watch.Added},-						{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), true, watch.Modified},-						{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), true, watch.Modified},-					}-				}-				return []*testWatchStruct{-					{baseNamespacedPod("t43-foo1", "t43-ns1"), false, ""},-					{baseNamespacedPod("t43-foo2", "t43-ns2"), false, ""},-					{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), false, ""},-					{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), false, ""},-				}-			}(),+			watchTests: []*testWatchStruct{+				{baseNamespacedPod("t43-foo1", "t43-ns1"), false, ""},+				{baseNamespacedPod("t43-foo2", "t43-ns2"), false, ""},+				{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), false, ""},+				{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), false, ""},+			}, 		}, 		{ 			name:          "namespaced watch, non-recursive, request without name, request without namespace, field selector with metadata.namespace", 			recursive:     false, 			fieldSelector: fields.ParseSelectorOrDie("metadata.namespace=t44-ns1"),-			watchTests: func() []*testWatchStruct {-				if isWatchCache {-					return []*testWatchStruct{

Serve legacy module aliases through a sys.meta_path finderPython · 60 + / 51 −

Introduces 7 new declarations in src/transformers/__init__.py.

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

src/transformers/__init__.py ↗ · 3 files

@@ -821,54 +829,22 @@         extra_objects={"__version__": __version__},     ) -    def _create_module_alias(alias: str, target: str) -> None:-        """-        Lazily redirect legacy module paths to their replacements without importing heavy deps.-        """-        module = types.ModuleType(alias)-        module.__doc__ = f"Alias module for backward compatibility with `{target}`."-        # Set __file__ explicitly so that inspect.py's hasattr(module, '__file__') check-        # never falls through to __getattr__ and triggers a premature (possibly circular) import.-        module.__file__ = None--        def _get_target():-            return importlib.import_module(target, __name__)--        module.__getattr__ = lambda name: getattr(_get_target(), name)-        module.__dir__ = lambda: dir(_get_target())--        sys.modules[alias] = module-        setattr(sys.modules[__name__], alias.rsplit(".", 1)[-1], module)--    _create_module_alias(f"{__name__}.tokenization_utils_fast", ".tokenization_utils_tokenizers")-    _create_module_alias(f"{__name__}.tokenization_utils", ".tokenization_utils_sentencepiece")-    _create_module_alias(f"{__name__}.image_processing_utils_fast", ".image_processing_backends")--    for _proc_file in sorted((Path(__file__).parent / "models").rglob("image_processing_*.py")):-        _model = _proc_file.parent.name-        _module = _proc_file.stem-        _target = f".models.{_model}.{_module}"-        _create_module_alias(f"{__name__}.models.{_model}.{_module}_fast", _target)--        # Also map XImageProcessorFast -> XImageProcessor for backward compat with old class names.

Unify watch event filtering into dedicated structGo · 43 + / 33 −

Introduces 3 new declarations in staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go.

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

staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go ↗ · 4 files

@@ -1276,29 +1274,41 @@ func forgetWatcher(c *Cacher, w *cacheWatcher, index int, selector watchSelector 	} } -func filterWithAttrsAndPrefixFunction(prefix string, p storage.SelectionPredicate, recursive bool, groupResource schema.GroupResource) filterWithAttrsFunc {-	return func(objKey string, label labels.Set, field fields.Set, obj runtime.Object) bool {-		if recursive {-			if !key.HasPathPrefix(objKey, prefix) {-				return false-			}-		} else if objKey != prefix {-			return false-		}-		if !p.MatchesObjectAttributes(label, field) {-			return false-		}-		matches, err := p.MatchesSharding(obj)-		if err != nil {-			utilruntime.HandleError(fmt.Errorf("shard matching failed for %v: %w", groupResource, err))-			return false-		}-		if !matches {-			metrics.RecordWatchFilteredEvent(groupResource)+type watchEventFilter struct {+	prefix        string+	opts          storage.ListOptions+	groupResource schema.GroupResource+}++func newWatchEventFilter(prefix string, opts storage.ListOptions, groupResource schema.GroupResource) watchEventFilter {+	return watchEventFilter{+		prefix:        prefix,+		opts:          opts,+		groupResource: groupResource,