Oct 8, 2026

kubelet: run the node admission checks without the scheduler's plugin registryGo · 298 + / 293 −

Introduces 10 new declarations in pkg/scheduler/framework/plugins/helper/resource_fit.go.

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

pkg/scheduler/framework/plugins/helper/resource_fit.go ↗ · 8 files

@@ -0,0 +1,258 @@+/*+Copyright The Kubernetes Authors.++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.+*/++package helper++import (+	"fmt"+	"strings"++	v1 "k8s.io/api/core/v1"+	"k8s.io/apimachinery/pkg/util/sets"+	"k8s.io/component-helpers/resource"+	fwk "k8s.io/kube-scheduler/framework"+	v1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"+	"k8s.io/kubernetes/pkg/scheduler/framework"+)++// ResourceRequestsOptions contains feature gate flags for resource request computation.+type ResourceRequestsOptions struct {+	EnablePodLevelResources                            bool

Add `rustc::missing_generic_type_visitable` lintRust · 126 + / 57 −

Introduces 5 new declarations in compiler/rustc_lint/src/internal.rs.

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

compiler/rustc_lint/src/internal.rs ↗ · 11 files

@@ -873,3 +876,63 @@ impl<'tcx> LateLintPass<'tcx> for RustcMustMatchExhaustively {         }     } }++declare_tool_lint! {+    /// The `missing_generic_type_visitable_derive` lint detects types implementing `TypeVisitable`+    /// but not deriving `GenericTypeVisitable`.+    ///+    /// `GenericTypeVisitable` is the analog of `TypeVisitable` used by rust-analyzer, and needs to+    /// be implemented whenever `TypeVisitable` is. See [`rustc_type_ir::generic_visit`] for more+    /// information.+    pub rustc::MISSING_GENERIC_TYPE_VISITABLE_DERIVE,+    // This lint is meant to be manually enabled in selected crates (currently only `rustc_type_ir`)+    Allow,+    "Forbid implementing `TypeVisitable` without deriving `GenericTypeVisitable`",+    report_in_external_macro: true+}++declare_lint_pass!(MissingGenericTypeVisitableDerive => [MISSING_GENERIC_TYPE_VISITABLE_DERIVE]);++impl<'tcx> LateLintPass<'tcx> for MissingGenericTypeVisitableDerive {+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {+        // lint ADTs except unions, as neither trait can be implemented on the latter+        if matches!(item.kind, hir::ItemKind::Struct(..) | hir::ItemKind::Enum(..))+            && let Some(regular_id) = cx.tcx.get_diagnostic_item(sym::TypeVisitable)+            && let Some(generic_id) = cx.tcx.get_diagnostic_item(sym::GenericTypeVisitable)+            && let (infcx, param_env) = cx.tcx.infer_ctxt().build_with_typing_env(cx.typing_env())+            && let self_ty = {+                let self_id = item.owner_id.to_def_id();+                let args = infcx.fresh_args_for_item(DUMMY_SP, self_id);+                cx.tcx.type_of(self_id).instantiate(cx.tcx, args).skip_norm_wip()+            }+            // check whether `Self: TypeVisitable<I>` holds for some `I`..

🚨 Generation cleanup in pipelinesPython · 138 + / 140 −

Introduces 2 new declarations in src/transformers/pipelines/base.py.

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

src/transformers/pipelines/base.py ↗ · 12 files

@@ -877,61 +883,22 @@ def __init__(             self.model.to(self.device)          # If it's a generation pipeline and the model can generate:-        # 1 - create a local generation config. This is done to avoid side-effects on the model as we apply local-        # tweaks to the generation config.+        # 1 - set aside the generation parameters, which apply to every call (see `_prepare_generate_kwargs`).         # 2 - load the assistant model if it is passed.         if self._pipeline_calls_generate and self.model.can_generate():             self.assistant_model, self.assistant_tokenizer = load_assistant_model(                 self.model, kwargs.pop("assistant_model", None), kwargs.pop("assistant_tokenizer", None)             )             self.prefix = self.model.config.prefix if hasattr(self.model.config, "prefix") else None-            # Priority order: kwargs > user_generation_config > model.generation_config > default_pipeline_generation_config-            default_pipeline_generation_config = getattr(self, "_default_generation_config", None)-            user_generation_config = kwargs.pop("generation_config", None)-            if hasattr(self.model, "_prepare_generation_config"):-                base_config = user_generation_config or copy.deepcopy(self.model.generation_config)-                if default_pipeline_generation_config is not None:-                    base_config.update(-                        **default_pipeline_generation_config.to_dict(),-                        defaults_only=True,-                        allow_custom_entries=True,-                    )-                prepared_generation_config, kwargs = self.model._prepare_generation_config(-                    generation_config=base_config, **kwargs-                )-                self.generation_config = prepared_generation_config-                # if the `max_new_tokens` is set to the pipeline default, but `max_length` is set to a non-default-                # value: let's honor `max_length`. E.g. we want Whisper's default `max_length=448` take precedence-                # over over the pipeline's length default.-                if (-                    default_pipeline_generation_config is not None-                    and default_pipeline_generation_config.max_new_tokens is not None  # there's a pipeline default

BUG: DataFrame.agg with a list of funcs casts uint64 and bool results (GH#65031)Python · 29 + / 5 −

Introduces 1 new declaration in pandas/core/apply.py.

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

pandas/core/apply.py ↗ · 2 files

@@ -1172,9 +1188,17 @@ def _agg_list_like_frame_reductions(self) -> DataFrame | None:                     # by the columns; anything else would silently misalign                     # in the concat below.                     return None-                # to_frame().T avoids the slow DataFrame(list-of-Series) path-                group_pieces.append(row.to_frame(func_name).T)-            pieces.append(concat(group_pieces))+                rows.append(row)++            # to_frame().T avoids the slow DataFrame(list-of-Series) path+            frames = [+                row.to_frame(name).T for name, row in zip(func_names, rows, strict=True)+            ]+            if _stack_as_object([row.dtype for row in rows]):+                # GH#65031 see test_agg_list_like_unsigned_and_signed_is_object+                # and test_agg_list_like_bool_with_numeric_is_object+                frames = [frame.astype(object) for frame in frames]+            pieces.append(concat(frames))          result = concat(pieces, axis=1)         result = result.reindex(columns=obj.columns)

model : add LiquidAI/d1-omni-600M decision modelC++ · 647 + / 27 −

Introduces 4 new declarations in src/models/lfm2.cpp.

Adds new framework internals rather than adjusting what was there. Read the linked PR for the surrounding test context.

src/models/lfm2.cpp ↗ · 21 files

@@ -294,6 +345,242 @@ llama_model_lfm2::graph<iswa>::graph(const llama_model & model, const llm_graph_     ggml_build_forward_expand(gf, cur); } +// media entries (an image or audio prefix) are embeddings, text entries are tokens+static bool lfm2_is_media(const llama_ubatch & ubatch, int64_t i) {+    return ubatch.is_mixed() ? ubatch.type[i] != 0 : ubatch.token == nullptr;+}++// non-causal within a sequence, the media never reads the text, so it is a function of the media alone+// in the head, the text and the media only read their own kind+class llm_graph_input_attn_media : public llm_graph_input_attn_no_cache {+public:+    llm_graph_input_attn_media(const llama_hparams & hparams, const llama_cparams & cparams, bool is_head) :+        llm_graph_input_attn_no_cache(hparams, cparams), is_head(is_head) {}++    void set_input(const llama_ubatch * ubatch) override {+        const int64_t n_tokens = ubatch->n_tokens;++        std::vector<bool> is_media(n_tokens);+        for (int64_t i = 0; i < n_tokens; ++i) {+            is_media[i] = lfm2_is_media(*ubatch, i);+        }++        const auto fill_mask = [&](auto * data, auto zero, auto ninf) {+            for (int64_t i1 = 0; i1 < n_tokens; ++i1) {+                for (int64_t i0 = 0; i0 < n_tokens; ++i0) {+                    bool visible = ubatch->seq_id[i0][0] == ubatch->seq_id[i1][0];+                    if (is_head) {+                        visible = visible && is_media[i0] == is_media[i1];+                    } else {+                        visible = visible && !(is_media[i1] && !is_media[i0]);+                    }+                    data[i1 * n_tokens + i0] = visible ? zero : ninf;