Oct 14, 2026 – Oct 20, 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",

Structure watch processing into clean 2 stagesGo · 56 + / 60 −

Introduces 3 new declarations in staging/src/k8s.io/apiserver/pkg/storage/cacher/cache_watcher.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/cache_watcher.go ↗ · 3 files

@@ -447,42 +447,29 @@ func (c *cacheWatcher) sendWatchCacheEvent(event *watchCacheEvent) (builtAt, sen 	return builtAt, sentAt } -// streamInterval sends every event of cacheInterval to the result channel,-// advancing *resourceVersion to the highest resourceVersion of any event the-// interval yielded (including events the watcher's filter drops). It returns-// the number of events the interval yielded. A non-nil error means the-// interval has been invalidated (the watch cache history moved past it) and-// can no longer serve events; the returned count is then meaningless.-func (c *cacheWatcher) streamInterval(cacheInterval *watchCacheInterval, resourceVersion *uint64) (int, error) {-	eventCount := 0-	for event, err := range cacheInterval.All() {-		if err != nil {-			return eventCount, err-		}-		c.sendWatchCacheEvent(event)--		// With some events already sent, update resourceVersion so that-		// events that were buffered and not yet processed won't be delivered-		// to this watcher second time causing going back in time.-		//-		// There is one case where events are not necessary ordered by-		// resourceVersion, being a case of watching from resourceVersion=0,-		// which at the beginning returns the state of each objects.-		// For the purpose of it, we need to max it with the resource version-		// that we have so far.-		if event.ResourceVersion > *resourceVersion {-			*resourceVersion = event.ResourceVersion-		}-		eventCount++-	}-	return eventCount, nil-}

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

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.

Rollup of 7 pull requestsRust · 207 + / 188 −

Introduces 5 new declarations in library/std/src/sys/stdio/windows.rs.

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

library/std/src/sys/stdio/windows.rs ↗ · 38 files

@@ -135,141 +138,125 @@ fn write_console_utf16(     incomplete_utf8: &mut IncompleteUtf8,     handle: c::HANDLE, ) -> io::Result<usize> {-    if incomplete_utf8.len > 0 {-        assert!(-            incomplete_utf8.len < 4,-            "Unexpected number of bytes for incomplete UTF-8 codepoint."-        );-        if data[0] >> 6 != 0b10 {-            // not a continuation byte - reject-            incomplete_utf8.len = 0;-            return Err(io::const_error!(-                io::ErrorKind::InvalidData,-                "Windows stdio in console mode does not support writing non-UTF-8 byte sequences",-            ));-        }-        incomplete_utf8.bytes[incomplete_utf8.len as usize] = data[0];-        incomplete_utf8.len += 1;-        let char_width = utf8_char_width(incomplete_utf8.bytes[0]);-        if (incomplete_utf8.len as usize) < char_width {-            // more bytes needed-            return Ok(1);-        }-        let s = str::from_utf8(&incomplete_utf8.bytes[0..incomplete_utf8.len as usize]);-        incomplete_utf8.len = 0;-        match s {-            Ok(s) => {-                assert_eq!(char_width, s.len());-                let written = write_valid_utf8_to_console(handle, s)?;-                assert_eq!(written, s.len()); // guaranteed by write_valid_utf8_to_console() for single codepoint writes-                return Ok(1);-            }-            Err(_) => {

KEP-5958: Add client-go DropManagedFields and use it in kube-controller-managerGo · 131 + / 12 −

Introduces 10 new declarations in staging/src/k8s.io/client-go/rest/client.go.

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

staging/src/k8s.io/client-go/rest/client.go ↗ · 10 files

@@ -344,3 +379,54 @@ func (n clientNegotiatorWithCBORSequenceStreamDecoder) StreamDecoder(contentType 	}  }++type clientNegotiatorDroppingManagedFields struct {+	negotiator runtime.ClientNegotiator+}++func (n clientNegotiatorDroppingManagedFields) Encoder(contentType string, params map[string]string) (runtime.Encoder, error) {+	return n.negotiator.Encoder(contentType, params)+}++func (n clientNegotiatorDroppingManagedFields) Decoder(contentType string, params map[string]string) (runtime.Decoder, error) {+	decoder, err := n.negotiator.Decoder(contentType, params)+	if err != nil {+		return nil, err+	}+	return decoderDroppingManagedFields{decoder}, nil+}++func (n clientNegotiatorDroppingManagedFields) StreamDecoder(contentType string, params map[string]string) (runtime.Decoder, runtime.Serializer, runtime.Framer, error) {+	decoder, serializer, framer, err := n.negotiator.StreamDecoder(contentType, params)+	if err != nil {+		return nil, nil, nil, err+	}+	return decoderDroppingManagedFields{decoder}, serializer, framer, nil+}++type decoderDroppingManagedFields struct {+	decoder runtime.Decoder+}++func (d decoderDroppingManagedFields) Decode(data []byte, defaults *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {

fix(core): keep op contexts alive until the isolate is disposedRust · 105 + / 12 −

Introduces 4 new declarations in cli/tools/lint/plugins.rs.

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

cli/tools/lint/plugins.rs ↗ · 11 files

@@ -103,6 +103,53 @@ v8_static_strings! { pub struct PluginHostProxy {   tx: mpsc::Sender<PluginHostRequest>,   pub(crate) plugin_info: Arc<Mutex<Vec<PluginInfo>>>,+  // Must be declared after `tx`: fields are dropped in declaration order, and+  // the plugin host's run loop only ends once `tx` has been dropped.+  _thread: PluginHostThread,+}++/// How long dropping a [`PluginHostProxy`] waits for the plugin host to tear+/// down its worker. Teardown normally takes milliseconds; the bound only+/// guarantees that `deno lint` can never hang on it.+const PLUGIN_HOST_TEARDOWN_TIMEOUT: std::time::Duration =+  std::time::Duration::from_secs(10);++/// The thread running the [`PluginHost`].+///+/// On drop, waits until the plugin host has torn down its worker, and with it+/// the V8 isolate. Without this the thread was detached, so the process could+/// exit while V8 was still disposing of the isolate on that thread.+#[derive(Debug)]+struct PluginHostThread {+  join_handle: Option<std::thread::JoinHandle<Result<(), AnyError>>>,+  /// Disconnected once the plugin host future, and the worker it owns, have+  /// been dropped. (In a `Mutex` only because `PluginHostProxy` is `Sync`.)+  worker_dropped_rx: Mutex<std::sync::mpsc::Receiver<()>>,+}++impl Drop for PluginHostThread {+  fn drop(&mut self) {+    match self+      .worker_dropped_rx+      .get_mut()+      .recv_timeout(PLUGIN_HOST_TEARDOWN_TIMEOUT)