Oct 8, 2026 – Oct 14, 2026

Add scripts/find_and_fix_pep798.pyPython · 245 + / 0 −

Introduces 13 new declarations in scripts/find_and_fix_pep798.py.

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

scripts/find_and_fix_pep798.py ↗ · 3 files

@@ -0,0 +1,245 @@+#!/usr/bin/env -S uv run --script+#+# /// script+# requires-python = ">=3.13"+# dependencies = []+# ///++"""+Find (and optionally fix) opportunities to use PEP 798 in Python source files.++PEP 798 allows unpacking inside comprehensions and generator expressions:+https://peps.python.org/pep-0798/++The following flattening patterns are detected:++    [y for x in xs for y in x]                      ->  [*x for x in xs]+    {y for x in xs for y in x}                      ->  {*x for x in xs}+    (y for x in xs for y in x)                      ->  (*x for x in xs)+    {k: v for d in ds for k, v in d.items()}        ->  {**d for d in ds}++Only the simplest, always-equivalent forms are rewritten: exactly two ``for``+clauses, no ``async``, and no ``if`` filter on the inner clause.  Nested+candidates are fixed innermost first; re-run the script to catch any leftovers.+The rewritten source uses Python 3.15+ syntax, so fixed files need 3.15+.++Usage:+    scripts/find_and_fix_pep798.py [--fix] PATH [PATH ...]++Without ``--fix`` the script only reports and exits with status 1 if any+opportunities were found.+"""++import argparse

ENH: sniff sep=None with the C engine in read_csv (GH#9645)Python · 105 + / 9 −

Introduces 5 new declarations in pandas/io/parsers/readers.py.

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

pandas/io/parsers/readers.py ↗ · 7 files

@@ -3643,3 +3689,53 @@ def _validate_skipfooter(kwds: dict[str, Any]) -> None:             raise ValueError("'skipfooter' not supported for iteration")         if kwds.get("nrows"):             raise ValueError("'skipfooter' not supported with 'nrows'")+++def _iter_physical_lines(+    handle: IO[Any], chunks: list[bytes | str], lineterminator: str | None+) -> Iterator[bytes | str]:+    """+    Yield each line of ``handle`` without its terminator, appending every chunk+    read to ``chunks``.+    """+    eol: re.Pattern[Any] | None = None+    partial: list[Any] = []+    skip_lf = False+    while True:+        chunk = handle.read(_SNIFF_CHUNK_SIZE)+        if not chunk:+            tail = partial[0][:0].join(partial) if partial else ""+            if tail:+                yield tail+            return+        chunks.append(chunk)+        if eol is None:+            pattern = re.escape(lineterminator) if lineterminator else r"\r\n|\r|\n"+            eol = re.compile(pattern.encode() if isinstance(chunk, bytes) else pattern)+        start = 0+        if skip_lf and chunk[:1] in (b"\n", "\n"):+            # the second half of a "\r\n" split across chunks+            start = 1+        for match in eol.finditer(chunk, start):+            partial.append(chunk[start : match.start()])+            yield chunk[:0].join(partial)

v1/systemone endpoint Python · 444 + / 0 −

Introduces 28 new declarations in src/transformers/cli/serving/systemone.py.

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

src/transformers/cli/serving/systemone.py ↗ · 5 files

@@ -0,0 +1,423 @@+# Copyright 2026 The HuggingFace Team. All rights reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+#     http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+"""+Handler for the /v1/systemone endpoint (System One typed decisions, in Jev's request and answer shapes).++Answers typed questions (`choice`, `score`, `noul`) about a `state` with a probability for every allowed answer. No+text is generated: each allowed answer gets a single-token label, and its probability is read from the model's logits+in one forward pass.+"""++import json+import string+from dataclasses import dataclass+from pathlib import Path+from typing import TYPE_CHECKING, Annotated, Any, Literal++from ...utils import logging+from ...utils.import_utils import is_serve_available+++if is_serve_available():+    from fastapi import HTTPException

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-}

MIR move elimination [3/6]: PreciseLivenessRust · 646 + / 1 −

Introduces 41 new declarations in compiler/rustc_mir_dataflow/src/impls/precise_liveness.rs.

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

compiler/rustc_mir_dataflow/src/impls/precise_liveness.rs ↗ · 21 files

@@ -0,0 +1,596 @@+//! Computes the points where each local must have a distinct allocation.+//!+//! The result is a [`SparseIntervalMatrix`] with one row per local. Two locals+//! may share the same address only if their rows are disjoint. To model MIR+//! statements where a source operand and destination place may share an+//! address, each statement and terminator is split into an early point, where+//! operands are read, and a late point, where destinations are written.+//!+//! A local live range starts at the late point of any statement or terminator+//! that writes to it without a `Deref` projection. It ends at `StorageLive` or+//! `StorageDead`, or at the early point of a whole-local move operand or the+//! last use of that local on a control-flow path (only for locals whose address+//! is never observed). This happens at `StorageLive` because it resets a local+//! to an uninitialized state.+//!+//! `Call` terminators are handled specially: move operands are kept live+//! through the late point of the terminator so they conflict with each other+//! and with the destination place. This matches the runtime behavior where the+//! place is donated to the callee for the duration of the call.+//!+//! The analysis consists of three passes:+//!+//! 1. A backward value-liveness analysis which identifies the last point at+//!    which each local is directly used in each control flow path. This is used+//!    to shorten the lifetime of unborrowed locals to their last use.+//! 2. A forward allocation-liveness analysis which uses that information+//!    together with writes, moves, and storage markers to compute which+//!    allocations may be live on entry to each block.+//! 3. A final walk using those entry states which constructs the matrix and+//!    distinguishes whether each effect happens at the early or late point of a+//!    statement or terminator.++use rustc_index::IndexVec;

Report periodic progress during index builds and idxpack conversionPython · 278 + / 205 −

Introduces 4 new declarations in scripts/dataloading/convert_indexes_to_idxpack.py.

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

scripts/dataloading/convert_indexes_to_idxpack.py ↗ · 4 files

@@ -1202,144 +1247,152 @@ def _build_native_tar_ordinal_array_specs(     map_summaries: list[list[NativeTarOrdinalMapBuildSummary | None]] = []     tasks = []     manifest_keys = []-    for map_index, spec in enumerate(maps):-        manifest_index_paths = tuple(-            _resolve_local_sidecar(manifest_path, indexes_root) for manifest_path in spec.manifest_paths-        )-        if spec.aggregate_manifest:-            aggregate_arrays, snapshot, summary = _build_aggregate_native_tar_array_specs(-                spec,-                map_index,-                temporary_directory,-                manifest_index_paths[0],-                indexes_root=indexes_root,-                index_path_overrides=index_path_overrides,-                source_size_overrides=source_size_overrides,-                include_member_ordinals=include_member_ordinals,+    with _log_progress("Preparing native-tar routes"):+        for map_index, spec in enumerate(maps):+            manifest_index_paths = tuple(+                _resolve_local_sidecar(manifest_path, indexes_root) for manifest_path in spec.manifest_paths             )-            arrays.extend(aggregate_arrays)-            map_snapshots.append(snapshot)-            map_summaries.append([summary])-        else:-            assert include_member_ordinals-            tar_index_paths = tuple(-                (-                    index_path_overrides[tar_path]-                    if tar_path in index_path_overrides-                    else _resolve_local_sidecar(tar_path, indexes_root)+            if spec.aggregate_manifest:

SpeechLM vLLM: serve FP8 and NVFP4 ModelOpt checkpoints (quantized decoder + prequantized FP8 audio encoder)Python · 306 + / 6 −

Introduces 12 new declarations in nemo/collections/speechlm2/vllm/salm/fp8_encoder.py.

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

nemo/collections/speechlm2/vllm/salm/fp8_encoder.py ↗ · 8 files

@@ -0,0 +1,270 @@+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+#     http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.++"""FP8 audio encoder for SpeechLM checkpoints quantized with ModelOpt FP8.++A checkpoint describes its audio encoder's quantization the way it describes its+decoder's, in the ModelOpt ``quantization_config`` of ``config.json``+(``quant_algo: FP8``): every Linear of the perception module that no ``ignore``+entry matches is quantized. Such a layer stores an FP8 E4M3 ``weight``, a float32+scalar ``weight_scale`` and a float32 scalar ``input_scale``, the static per-tensor+activation scale, both in the divisor convention ``x_fp8 = x / scale``. A+speaker-aware checkpoint keeps its diarizer, the ASR encoder's input projection and+the connector unquantized by listing them::++    "ignore": [..., "perception.encoder.diarization_model*",+               "perception.encoder.asr_encoder.pre_encode*", "perception.proj"]++The audio encoder runs as plain PyTorch inside the plugin rather than through vLLM's+quantized layers, so ``build_fp8_encoder`` applies vLLM's exclusion rule to the+perception Linears itself and builds ``FP8Linear`` layers for the quantized ones+when the model is constructed; the checkpoint then loads into them directly.+

turbopack: report an actionable error when Node.js child processes cannot connectRust · 168 + / 6 −

Introduces 18 new declarations in turbopack/crates/turbopack-node/src/evaluate.rs.

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

turbopack/crates/turbopack-node/src/evaluate.rs ↗ · 11 files

@@ -769,3 +826,76 @@ impl Issue for EvaluationIssue {         Some(self.source)     } }++/// Node.js child processes could not connect back to the parent process, which+/// makes it impossible to run any Node.js code (webpack loaders, PostCSS, ...).+#[turbo_tasks::value(shared)]+pub struct NodeJsConnectIssue {+    /// The source being transformed when the connection failed. The failure is+    /// unrelated to its contents, but this tells the user which transform hit it.+    pub source: IssueSource,+    /// What was being evaluated, e.g. the loader chain.+    pub crash_context: Option<RcStr>,+    /// Error output of the child process, describing why the connection failed.+    pub stderr: RcStr,+}++#[async_trait]+#[turbo_tasks::value_impl]+impl Issue for NodeJsConnectIssue {+    fn severity(&self) -> IssueSeverity {+        IssueSeverity::Error+    }++    async fn title(&self) -> Result<StyledString> {+        Ok(StyledString::Text(rcstr!(+            "Node.js worker processes could not connect to Turbopack"+        )))+    }++    fn stage(&self) -> IssueStage {+        IssueStage::Transform+    }

validate generic parameter remapping in delegationRust · 117 + / 37 −

Introduces 9 new declarations in compiler/rustc_hir_analysis/src/delegation.rs.

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

compiler/rustc_hir_analysis/src/delegation.rs ↗ · 6 files

@@ -23,46 +23,65 @@ struct ParamIndexRemapper<'tcx> {     tcx: TyCtxt<'tcx>,     remap_table: RemapTable,     delegation_parent_consts: FxHashSet<ty::ParamConst>,+    arg_kinds: Vec<ty::GenericArgKind<'tcx>>, } -impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ParamIndexRemapper<'tcx> {+impl<'tcx> ParamIndexRemapper<'tcx> {+    fn try_remap(+        &self,+        source_index: u32,+        expected_kind: ty::GenericArgKind<'tcx>,+    ) -> Result<u32, ()> {+        self.remap_table+            .get(&source_index)+            .copied()+            .filter(|&idx| {+                self.arg_kinds.get(idx as usize).is_some_and(|kind| {+                    std::mem::discriminant(&expected_kind) == std::mem::discriminant(kind)+                })+            })+            .ok_or(())+    }+}++impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for ParamIndexRemapper<'tcx> {+    type Error = ();+     fn cx(&self) -> TyCtxt<'tcx> {         self.tcx     } -    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {

Helpful suggestions for incorrect address-of mutability (2)Rust · 74 + / 11 −

Introduces 3 new declarations in compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs.

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

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs ↗ · 4 files

@@ -982,23 +982,62 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {         err.emit()     } -    fn suggest_ptr_null_mut(+    fn suggest_mut_addr(         &self,         expected_ty: Ty<'tcx>,         provided_ty: Ty<'tcx>,         arg: &hir::Expr<'tcx>,         err: &mut Diag<'_>,     ) {-        if let ty::RawPtr(_, hir::Mutability::Mut) = expected_ty.kind()-            && let ty::RawPtr(_, hir::Mutability::Not) = provided_ty.kind()-            && let hir::ExprKind::Call(callee, _) = arg.kind-            && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = callee.kind-            && let Res::Def(_, def_id) = path.res-            && self.tcx.get_diagnostic_item(sym::ptr_null) == Some(def_id)-        {+        match (expected_ty.kind(), provided_ty.kind(), arg.kind) {             // The user provided `ptr::null()`, but the function expects             // `ptr::null_mut()`.-            err.subdiagnostic(SuggestPtrNullMut { span: arg.span });+            (+                ty::RawPtr(_, hir::Mutability::Mut),+                ty::RawPtr(_, hir::Mutability::Not),+                hir::ExprKind::Call(callee, _),+            ) if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = callee.kind+                && let Res::Def(_, def_id) = path.res+                && self.tcx.get_diagnostic_item(sym::ptr_null) == Some(def_id) =>+            {+                err.subdiagnostic(SuggestPtrNullMut { span: arg.span });+            }+            // &mut T expected, &T or *const/mut T found

Turbopack: improve segment config parsingRust · 271 + / 96 −

Introduces 8 new declarations in crates/next-core/src/segment_config.rs.

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

crates/next-core/src/segment_config.rs ↗ · 19 files

@@ -157,30 +202,113 @@ impl NextSegmentConfig {             Ok(())         }         let Self {+            rsc,             dynamic,             dynamic_params,             revalidate,+            max_duration,             fetch_cache,             runtime,             preferred_region,-            ..+            // TODO what about these?+            instant: _,+            prefetch: _,+            ensure_static: _,+            // Don't need merging+            middleware_matcher: _,+            unstable_allow_dynamic: _,+            generate_image_metadata: _,+            generate_sitemaps: _,+            generate_static_params: _,         } = self;+        // Carry the leaf page's RSC classification up through its loader-tree branch. Unlike route+        // segment config, classifications in different parallel branches are not conflicts.+        *rsc = (*rsc).or(parallel_config.rsc);         merge_parallel(dynamic, &parallel_config.dynamic, "dynamic")?;         merge_parallel(             dynamic_params,             &parallel_config.dynamic_params,             "dynamicParams",         )?;         merge_parallel(revalidate, &parallel_config.revalidate, "revalidate")?;

Add Kolibri 1Python · 951 + / 0 −

Introduces 61 new declarations in src/transformers/models/kolibri1/modeling_kolibri1.py.

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

src/transformers/models/kolibri1/modeling_kolibri1.py ↗ · 12 files

@@ -0,0 +1,599 @@+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨+#           This file was automatically generated from src/transformers/models/kolibri1/modular_kolibri1.py.+#               Do NOT edit this file manually as any edits will be overwritten by the generation of+#             the file from the modular. If any change should be done, please apply the change to the+#                          modular_kolibri1.py file directly. One of our CI enforces this.+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨+# Copyright 2026 The HuggingFace Inc. team. All rights reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+#     http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.++from collections.abc import Callable++import torch+import torch.nn.functional as F+from torch import nn++from ... import initialization as init+from ...activations import ACT2FN+from ...cache_utils import Cache, DynamicCache+from ...generation import GenerationMixin+from ...integrations import use_experts_implementation, use_kernel_forward_from_hub+from ...masking_utils import create_causal_mask, create_sliding_window_causal_mask+from ...modeling_flash_attention_utils import FlashAttentionKwargs