Sep 20, 2026

BUG: named agg result depended on the output name matching the column name (GH#63743)Python · 40 + / 4 −

Introduces 3 new declarations in pandas/core/apply.py.

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

pandas/core/apply.py ↗ · 4 files

@@ -1902,10 +1902,22 @@ def reconstruct_func(     names, and the reconstructed order of columns.     If relabeling is False, the columns and order will be None. +    Named aggregation is the one exception: when ``allow_skip_normalization`` is+    True, every output name equals its source column name, and every aggfunc+    reduces to a scalar, relabeling is reported as False (and columns/order as+    None) even though named aggregation was used, because the caller can consume+    the un-normalized func directly.+     Parameters     ----------     func: agg function (e.g. 'min' or Callable) or list of agg functions         (e.g. ['min', np.max]) or dictionary (e.g. {'A': ['min', np.max]}).+    allow_skip_normalization: bool, default False+        Whether the caller can handle the un-normalized ``{column: aggfunc}`` form+        that named aggregation reduces to when every output name equals its source+        column name and every aggfunc is a scalar reduction. Callers that rely on+        ``columns``/``order`` being returned whenever named aggregation was used+        must leave this False.     **kwargs: dict, kwargs used in is_multi_agg_with_relabel and         normalize_keyword_aggregation function for relabelling 

[Feature] Implemented DES Algorithm in ECB modePython · 557 + / 0 −

Introduces 16 new declarations in ciphers/des_ecb.py.

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

ciphers/des_ecb.py ↗ · 2 files

@@ -0,0 +1,557 @@+"""+Python program for DES (Data Encryption Standard) using Electronic Codebook (ECB) mode.++DES is a symmetric-key block cipher that encrypts data in fixed-size blocks (64 bits).+In ECB mode, the plaintext is divided into 64-bit blocks, and each block is encrypted+independently using the same key. This makes ECB the simplest block cipher mode, but+also one of the least secure, as identical plaintext blocks will produce identical+ciphertext blocks.++This implementation of DES includes key scheduling, encryption, and decryption.+It uses standard DES operations such as initial and final permutations, expansion,+permutation, and S-box lookups. Padding is applied to ensure the plaintext length is+a multiple of 64 bits.++Warning: ECB mode is not secure for most use cases due to its vulnerability to block+repetition analysis. Consider using a more secure mode of operation, such as CBC+(Cipher Block Chaining), for sensitive data encryption.++References:+- Handbook of Applied Cryptography (Algorithm 7.82)+- Handbook of Applied Cryptography (Algorithm 7.83)+- Handbook of Applied Cryptography (Algorithm 9.29)+- https://en.wikipedia.org/wiki/Data_Encryption_Standard+"""++import random++# fmt: off++# Initial Permutation Table+IP = [58, 50, 42, 34, 26, 18, 10, 2,+      60, 52, 44, 36, 28, 20, 12, 4,+      62, 54, 46, 38, 30, 22, 14, 6,

even more cleanups for `rustc_builtin_macros`Rust · 155 + / 265 −

Introduces 5 new declarations in compiler/rustc_builtin_macros/src/deriving/generic/mod.rs.

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

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs ↗ · 14 files

@@ -965,70 +927,66 @@ impl<'a> MethodDef<'a> {         !self.explicit_self     } -    fn extract_arg_details(-        &self,-        cx: &ExtCtxt<'_>,-        trait_: &TraitDef<'_>,-        type_ident: Ident,-        generics: &Generics,-    ) -> ArgDetails {+    fn extract_arg_details(&self, cx: &ExtCtxt<'_>, trait_: &TraitDef<'_>) -> ArgDetails {         let mut selflike_args = ThinVec::new();         let mut nonselflike_args = Vec::new();-        let mut nonself_arg_tys = Vec::new();         let span = trait_.span; -        let explicit_self = self.explicit_self.then(|| {+        if self.explicit_self {             // This constructs a fresh `self` path.             selflike_args.push(cx.expr_self(span));-            respan(span, SelfKind::Region(None, ast::Mutability::Not))-        });+        }          for (ty, name) in self.nonself_args.iter() {-            let ast_ty = ty.to_ty(cx, span, type_ident, generics);             let ident = Ident::new(*name, span);-            nonself_arg_tys.push((ident, ast_ty));-             let arg_expr = cx.expr_ident(span, ident);              match ty {                 // Selflike (`&Self`) arguments only occur in non-static methods.

stream: trim per-stream costs in webstreamsJavaScript · 103 + / 150 −

Introduces 5 new declarations in lib/internal/webstreams/readablestream.js.

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

lib/internal/webstreams/readablestream.js ↗ · 3 files

@@ -1350,57 +1343,29 @@ ObjectDefineProperties(ReadableByteStreamController.prototype, {   [SymbolToStringTag]: getNonWritablePropertyDescriptor(ReadableByteStreamController.name), }); -function InternalReadableStream(start, pull, cancel, highWaterMark, size) {-  ObjectSetPrototypeOf(this, ReadableStream.prototype);-  markTransferMode(this, false, true);-  this[kType] = 'ReadableStream';-  this[kState] = createReadableStreamState();-  const controller = new ReadableStreamDefaultController(kSkipThrow);+function createReadableStream(start, pull, cancel, highWaterMark = 1, size = defaultSizeAlgorithm) {+  const stream = new ReadableStream(kSkipThrow);   setupReadableStreamDefaultController(-    this,-    controller,+    stream,+    new ReadableStreamDefaultController(kSkipThrow),     start,     pull,     cancel,     highWaterMark,     size);-}--ObjectSetPrototypeOf(InternalReadableStream.prototype, ReadableStream.prototype);-ObjectSetPrototypeOf(InternalReadableStream, ReadableStream);--function createReadableStream(start, pull, cancel, highWaterMark = 1, size = defaultSizeAlgorithm) {-  const stream = new InternalReadableStream(start, pull, cancel, highWaterMark, size);--  // For spec compliance the InternalReadableStream must be a ReadableStream-  stream.constructor = ReadableStream;   return stream; }

BUG: preserve integer ordering in digitize monotonicity checkC · 10 + / 98 −

Reworks 65 lines of existing logic in numpy/_core/src/multiarray/compiled_base.c.

Changes how existing core implementation behaves. Tests changed with it, with code of their own.

numpy/_core/src/multiarray/compiled_base.c ↗ · 8 files

@@ -26,57 +26,6 @@ typedef enum {     PACK_ORDER_BIG } PACK_ORDER; -/*- * Returns -1 if the array is monotonic decreasing,- * +1 if the array is monotonic increasing,- * and 0 if the array is not monotonic.- */-static int-check_array_monotonic(const double *a, npy_intp lena)-{-    npy_intp i;-    double next;-    double last;--    if (lena == 0) {-        /* all bin edges hold the same value */-        return 1;-    }-    last = a[0];--    /* Skip repeated values at the beginning of the array */-    for (i = 1; (i < lena) && (a[i] == last); i++);--    if (i == lena) {-        /* all bin edges hold the same value */-        return 1;-    }--    next = a[i];-    if (last < next) {-        /* Possibly monotonic increasing */-        for (i += 1; i < lena; i++) {