Oct 19, 2026

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) {

Turbopack: don't scope hoist modules using direct evalRust · 107 + / 4 −

Introduces 3 new declarations in turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs.

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

turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs ↗ · 17 files

@@ -778,6 +779,76 @@ mod tests {         Ok(())     } +    /// Builds the var graph for `src` (parsed as a sloppy script unless it uses module syntax)+    /// and returns whether a direct `eval` was detected.+    fn detect_direct_eval(src: &str) -> bool {+        let cm: Arc<SourceMap> = Arc::new(SourceMap::new(FilePathMapping::empty()));+        let globals = Globals::new();+        GLOBALS.set(&globals, || {+            let fm = cm.new_source_file(FileName::Anon.into(), src.to_string());+            let mut m = parse_file_as_program(+                &fm,+                Default::default(),+                EsVersion::latest(),+                None,+                &mut vec![],+            )+            .unwrap();+            let unresolved_mark = Mark::new();+            let top_level_mark = Mark::new();+            m.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));+            let eval_context = EvalContext::new(+                Some(&m),+                unresolved_mark,+                top_level_mark,+                Default::default(),+                None,+            );+            let arena = Bump::new();+            create_graph(+                &arena,+                &m,+                &eval_context,

BUG: read_csv pyarrow engine silently wrapped out-of-range integer dtype (GH#38013)Python · 72 + / 4 −

Introduces 4 new declarations in pandas/io/_util.py.

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

pandas/io/_util.py ↗ · 4 files

@@ -271,6 +276,61 @@ def _post_convert_dtypes(     return df  +def _numpy_dtype(dtype: DtypeObj) -> np.dtype | None:+    # the numpy dtype underlying a column's dtype, if any+    if isinstance(dtype, np.dtype):+        return dtype+    if isinstance(dtype, pd.SparseDtype):+        return dtype.subtype+    if isinstance(dtype, (BaseMaskedDtype, pd.ArrowDtype)):+        return dtype.numpy_dtype+    return None+++def _can_wrap(old: DtypeObj, new: DtypeObj) -> bool:+    """+    Whether casting from ``old`` to ``new`` can wrap around an integer value.+    """+    old_np = _numpy_dtype(old)+    new_np = _numpy_dtype(new)+    if old_np is None or new_np is None:+        return False+    if new_np.kind not in "iu" or old_np.kind not in "iuf":+        return False+    # NA cannot wrap, so e.g. Int64 -> int64 is as safe as int64 -> int64+    return not np.can_cast(old_np, new_np)+++def validate_integer_casts(original: pd.DataFrame, casted: pd.DataFrame) -> None:+    """+    Apply validate_integer_cast to each column of a DataFrame cast.+    """+    for i, (old, new) in enumerate(zip(original.dtypes, casted.dtypes, strict=True)):

feat: Select the panel.ui design per session and resolve designs at render timePython · 59 + / 8 −

Introduces 6 new declarations in panel/ui/__init__.py.

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

panel/ui/__init__.py ↗ · 6 files

@@ -281,9 +285,40 @@ def _set_global_design(design):     "YT", ) ++def _select_design():+    """+    Selects the Material UI design unless another one is configured. Within a+    session only that session is switched, so classic applications served from+    the same process keep their design.+    """+    if state.curdoc is None:+        if _global_design() is None:+            _set_global_design(MaterialUIDesign)+    elif config.design is None:+        config.design = MaterialUIDesign+++class _DesignSelectingModule(types.ModuleType):+    """+    The module is imported once per process, so the sessions after the first+    select the design whenever they access a component through it.+    """++    def __getattribute__(self, name):+        if not name.startswith('__') and state.curdoc is not None:+            _select_design()+        return super().__getattribute__(name)++ if _global_design() is not _prior_design:     _set_global_design(_prior_design) -if config.design is None or config.design is MaterialDesign:

🚨 TP: give embeddings their own style, shard input embeddings by default, and shard widths that don't divide by the TP sizePython · 101 + / 56 −

Introduces 10 new declarations in src/transformers/distributed/tensor_parallel.py.

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

src/transformers/distributed/tensor_parallel.py ↗ · 16 files

@@ -360,6 +365,50 @@ def transform_output_post_forward(self, module, output, mesh):         return output  +class EmbeddingParallel(TensorParallelLayer):+    """Embedding with the token ids replicated on every rank. `shard_dim=0` is vocab-parallel: each rank holds a slice+    of the vocabulary, and the ranks' partial lookups are summed. `shard_dim=1` shards the hidden dim: each rank looks+    up a slice of every vector, and the slices are gathered. The sharded dim need not divide by the TP size."""++    def __init__(self, *, shard_dim: int = 0, use_local_output: bool = True):+        self.shard_dim = shard_dim+        self.use_local_output = use_local_output++    def should_use_local_tensors(self, module):+        return getattr(module, "_hf_quantized_needs_local_tp", False)++    def shard_param(self, module, param, mesh):+        meta = module._parameters.get(param)+        if meta is None:+            return+        module._parameters[param] = torch.nn.Parameter(+            distribute_tensor(meta, mesh, [Shard(self.shard_dim)], src_data_rank=None),+            requires_grad=meta.requires_grad,+        )++    def transform_inputs_pre_forward(self, module, args, kwargs, mesh):+        x = args[0]+        if self.should_use_local_tensors(module) and not isinstance(x, DTensor):+            return args, kwargs+        if not isinstance(x, DTensor):+            x = DTensor.from_local(x, mesh, [Replicate()], run_check=False)+        elif x.placements != (Replicate(),):+            x = x.redistribute(placements=[Replicate()])+        if self.should_use_local_tensors(module):