Oct 11, 2026 – Oct 17, 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

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",

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

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

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.+

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

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(_) => {

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

Write webpack dev manifests atomicallyTypeScript · 82 + / 1 −

Introduces 6 new declarations in packages/next/src/server/dev/atomic-manifest-output-fs.ts.

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

packages/next/src/server/dev/atomic-manifest-output-fs.ts ↗ · 4 files

@@ -0,0 +1,68 @@+import path from 'path'+import type { webpack } from 'next/dist/compiled/webpack/webpack'+import { writeFileAtomic } from '../../lib/fs/write-atomic'++type OutputFileSystem = NonNullable<webpack.Compiler['outputFileSystem']>+type WriteFile = OutputFileSystem['writeFile']+type WriteCallback = Parameters<WriteFile>[2]++const MANIFEST_FILE_RE = /manifest\.(?:js|json)$/i++/**+ * Whether the dev server reads this emitted file outside of webpack, e.g.+ * through `loadManifest` / `evalManifest`. `build-manifest.json`,+ * `next-font-manifest.json`, `page_client-reference-manifest.js` and so on.+ */+export function isManifestFile(filePath: string): boolean {+  return MANIFEST_FILE_RE.test(path.basename(filePath))+}++/**+ * Returns a webpack output file system that writes manifest files atomically.+ *+ * Webpack writes emitted assets in place, truncating the file first. In dev,+ * a request that renders an already-built route (it doesn't wait for an+ * in-flight rebuild) can read a manifest while it is being rewritten. It then+ * sees an empty or partial file and fails with `Manifest file is empty` or+ * `Unexpected end of JSON input`. Writing manifests with `writeFileAtomic`+ * (temp file + rename, the same helper Turbopack's manifests use) means a+ * reader sees either the old or the new manifest.+ *+ * Manifests are written straight to disk with Node's `fs`, bypassing the given+ * file system's `writeFile`. That is intended for Next.js's disk-backed dev output: the+ * dev server reads these manifests from disk with Node's `fs` anyway, and