helloadhavan/github_issues huggingface dataset:
Repository: nodejs/node
Pull request: test: skip sea tests on Linux ppc64le

Theses tests are failing when compiled with clang. Skip for now to avoid breaking the CI when we switch over to building with clang.

Refs: https://github.com/nodejs/node/issues/59561



Changed files:
filename: test/sequential/sequential.status
patch: @@ -51,3 +51,17 @@ test-tls-psk-client: PASS, FLAKY
 [$arch==arm]
 # https://github.com/nodejs/node/issues/49933
 test-watch-mode-inspect: SKIP
+
+[$system==linux && $arch==ppc64]
+# https://github.com/nodejs/node/issues/59561
+test-single-executable-application: SKIP
+test-single-executable-application-assets: SKIP
+test-single-executable-application-assets-raw: SKIP
+test-single-executable-application-disable-experimental-sea-warning: SKIP
+test-single-executable-application-empty: SKIP
+test-single-executable-application-exec-argv: SKIP
+test-single-executable-application-exec-argv-empty: SKIP
+test-single-executable-application-snapshot: SKIP
+test-single-executable-application-snapshot-and-code-cache: SKIP
+test-single-executable-application-snapshot-worker: SKIP
+test-single-executable-application-use-code-cache: SKIP
Repository: electron/electron
Pull request: fix: accent color should reflect system settings without restart

Backport of #47629

See that PR for details.


Notes: Fixed an issue where the window required restart in order to recognize system accent color setting change.


Changed files:
filename: shell/browser/native_window_views.h
patch: @@ -305,7 +305,7 @@ class NativeWindowViews : public NativeWindow,
   // Whether the window is currently being moved.
   bool is_moving_ = false;
 
-  std::variant<bool, SkColor> accent_color_ = true;
+  std::variant<std::monostate, bool, SkColor> accent_color_;
 
   std::optional<gfx::Rect> pending_bounds_change_;
 

filename: shell/browser/native_window_views_win.cc
patch: @@ -572,28 +572,42 @@ void NativeWindowViews::UpdateWindowAccentColor() {
   if (base::win::GetVersion() < base::win::Version::WIN11)
     return;
 
-  if (!IsAccentColorOnTitleBarsEnabled())
-    return;
-
   COLORREF border_color;
-  if (std::holds_alternative<bool>(accent_color_)) {
-    // Don't set accent color if the user has disabled it.
-    if (!std::get<bool>(accent_color_))
-      return;
+  bool should_apply_accent = false;
 
-    std::optional<DWORD> accent_color = GetAccentColor();
-    if (!accent_color.has_value())
-      return;
-
-    border_color =
-        RGB(GetRValue(accent_color.value()), GetGValue(accent_color.value()),
-            GetBValue(accent_color.value()));
-  } else {
+  if (std::holds_alternative<bool>(accent_color_)) {
+    bool force_accent = std::get<bool>(accent_color_);
+    if (!force_accent) {
+      should_apply_accent = false;
+    } else {
+      std::optional<DWORD> accent_color = GetAccentColor();
+      if (accent_color.has_value()) {
+        border_color = RGB(GetRValue(accent_color.value()),
+                           GetGValue(accent_color.value()),
+                           GetBValue(accent_color.value()));
+        should_apply_accent = true;
+      }
+    }
+  } else if (std::holds_alternative<SkColor>(accent_color_)) {
     SkColor color = std::get<SkColor>(accent_color_);
     border_color =
         RGB(SkColorGetR(color), SkColorGetG(color), SkColorGetB(color));
+    should_apply_accent = true;
+  } else if (std::holds_alternative<std::monostate>(accent_color_)) {
+    if (IsAccentColorOnTitleBarsEnabled()) {
+      std::optional<DWORD> accent_color = GetAccentColor();
+      if (accent_color.has_value()) {
+        border_color = RGB(GetRValue(accent_color.value()),
+                           GetGValue(accent_color.value()),
+                           GetBValue(accent_color.value()));
+        should_apply_accent = true;
+      }
+    }
   }
 
+  // Reset to default system colors when accent color should not be applied.
+  if (!should_apply_accent)
+    border_color = DWMWA_COLOR_DEFAULT;
   SetWindowBorderAndCaptionColor(GetAcceleratedWidget(), border_color);
 }
Repository: ollama/ollama
Pull request: Update macOS app setup command to `llama3`


Changed files:
filename: macapp/src/app.tsx
patch: @@ -19,7 +19,7 @@ export default function () {
   const [step, setStep] = useState<Step>(Step.WELCOME)
   const [commandCopied, setCommandCopied] = useState<boolean>(false)
 
-  const command = 'ollama run llama2'
+  const command = 'ollama run llama3'
 
   return (
     <div className='drag'>
Repository: ollama/ollama
Pull request: types/model: relax name length constraint from 2 to 1


Changed files:
filename: types/model/name.go
patch: @@ -113,16 +113,16 @@ type Name struct {
 //	      length:  [1, 350]
 //	  namespace:
 //	      pattern: alphanum { alphanum | "-" | "_" }*
-//	      length:  [2, 80]
+//	      length:  [1, 80]
 //	  model:
 //	      pattern: alphanum { alphanum | "-" | "_" | "." }*
-//	      length:  [2, 80]
+//	      length:  [1, 80]
 //	  tag:
 //	      pattern: alphanum { alphanum | "-" | "_" | "." }*
 //	      length:  [1, 80]
 //	  digest:
 //	      pattern: alphanum { alphanum | "-" | ":" }*
-//	      length:  [2, 80]
+//	      length:  [1, 80]
 //
 // Most users should use [ParseName] instead, unless need to support
 // different defaults than DefaultName.
@@ -254,7 +254,7 @@ func isValidLen(kind partKind, s string) bool {
 	case kindTag:
 		return len(s) >= 1 && len(s) <= 80
 	default:
-		return len(s) >= 2 && len(s) <= 80
+		return len(s) >= 1 && len(s) <= 80
 	}
 }
 

filename: types/model/name_test.go
patch: @@ -101,6 +101,11 @@ func TestParseNameParts(t *testing.T) {
 }
 
 var testCases = map[string]bool{ // name -> valid
+	"": false,
+
+	// minimal
+	"h/n/m:t@d": true,
+
 	"host/namespace/model:tag": true,
 	"host/namespace/model":     false,
 	"namespace/model":          false,
@@ -116,11 +121,12 @@ var testCases = map[string]bool{ // name -> valid
 	"h/nn/mm:t@sha256-1000000000000000000000000000000000000000000000000000000000000000": true, // bare minimum part sizes
 	"h/nn/mm:t@sha256:1000000000000000000000000000000000000000000000000000000000000000": true, // bare minimum part sizes
 
-	"m":        false, // model too short
-	"n/mm:":    false, // namespace too short
-	"h/n/mm:t": false, // namespace too short
-	"@t":       false, // digest too short
-	"mm@d":     false, // digest too short
+	// unqualified
+	"m":     false,
+	"n/m:":  false,
+	"h/n/m": false,
+	"@t":    false,
+	"m@d":   false,
 
 	// invalids
 	"^":      false,
@@ -140,8 +146,6 @@ var testCases = map[string]bool{ // name -> valid
 	"hh/nn/mm:-tt@dd": false,
 	"hh/nn/mm:tt@-dd": false,
 
-	"": false,
-
 	// hosts
 	"host:https/namespace/model:tag": true,
Repository: ggml-org/llama.cpp
Pull request: common: clarify instructions for bug reports

See discussion in https://github.com/ggml-org/llama.cpp/issues/18119 .

It seems I was too aggressive with trying to keep log messages short so the intent became unclear.

Changed files:
filename: common/common.cpp
patch: @@ -1092,7 +1092,7 @@ common_init_result::common_init_result(common_params & params) :
     auto cparams = common_context_params_to_llama(params);
 
     if (params.fit_params) {
-        LOG_INF("%s: fitting params to device memory, to report bugs during this step use -fit off (or --verbose if you can't)\n", __func__);
+        LOG_INF("%s: fitting params to device memory, for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on\n", __func__);
         llama_params_fit(params.model.path.c_str(), &mparams, &cparams,
             params.tensor_split, params.tensor_buft_overrides.data(), params.fit_params_target, params.fit_params_min_ctx,
             params.verbosity >= 4 ? GGML_LOG_LEVEL_DEBUG : GGML_LOG_LEVEL_ERROR);
Repository: huggingface/transformers
Pull request: Revert some breaking changes bnb

# What does this PR do?

This PR fixes issues related to bnb during a recent refactor. I didn't push some modifications 

Changed files:
filename: src/transformers/quantizers/auto.py
patch: @@ -121,17 +121,15 @@ class AutoQuantizationConfig:
     @classmethod
     def from_dict(cls, quantization_config_dict: dict):
         quant_method = quantization_config_dict.get("quant_method")
-        if quant_method is None:
+        # We need a special care for bnb models to make sure everything is BC ..
+        if quantization_config_dict.get("load_in_8bit", False) or quantization_config_dict.get("load_in_4bit", False):
+            suffix = "_4bit" if quantization_config_dict.get("load_in_4bit", False) else "_8bit"
+            quant_method = QuantizationMethod.BITS_AND_BYTES + suffix
+        elif quant_method is None:
             raise ValueError(
                 "The model's quantization config from the arguments has no `quant_method` attribute. Make sure that the model has been correctly quantized"
             )
 
-        if quant_method == QuantizationMethod.BITS_AND_BYTES:
-            if quantization_config_dict.get("load_in_8bit"):
-                quant_method += "_8bit"
-            else:
-                quant_method += "_4bit"
-
         if quant_method not in AUTO_QUANTIZATION_CONFIG_MAPPING:
             raise ValueError(
                 f"Unknown quantization type, got {quant_method} - supported types are:"
Repository: vercel/next.js
Pull request: [turbopack] Only send the filesystem caching timing messages for slow events

These are not very actionable for end users, but if they take more than 10s it might be a useful clue about system performance.

Closes PACK-5655

Changed files:
filename: turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
patch: @@ -1184,10 +1184,13 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
 
         if new_items {
             let elapsed = start.elapsed();
-            turbo_tasks().send_compilation_event(Arc::new(TimingEvent::new(
-                "Finished writing to filesystem cache".to_string(),
-                elapsed,
-            )));
+            // avoid spamming the event queue with information about fast operations
+            if elapsed > Duration::from_secs(10) {
+                turbo_tasks().send_compilation_event(Arc::new(TimingEvent::new(
+                    "Finished writing to filesystem cache".to_string(),
+                    elapsed,
+                )));
+            }
         }
 
         Some((snapshot_time, new_items))

filename: turbopack/crates/turbo-tasks-backend/src/database/turbo/mod.rs
patch: @@ -1,4 +1,10 @@
-use std::{cmp::max, path::PathBuf, sync::Arc, thread::available_parallelism, time::Instant};
+use std::{
+    cmp::max,
+    path::PathBuf,
+    sync::Arc,
+    thread::available_parallelism,
+    time::{Duration, Instant},
+};
 
 use anyhow::{Ok, Result};
 use parking_lot::Mutex;
@@ -135,8 +141,11 @@ fn do_compact(
     })?;
     if ran {
         let elapsed = start.elapsed();
-        turbo_tasks()
-            .send_compilation_event(Arc::new(TimingEvent::new(message.to_string(), elapsed)));
+        // avoid spamming the event queue with information about fast operations
+        if elapsed > Duration::from_secs(10) {
+            turbo_tasks()
+                .send_compilation_event(Arc::new(TimingEvent::new(message.to_string(), elapsed)));
+        }
     }
     Ok(())
 }
Repository: facebook/react
Pull request: Test infra: Support gate('enableFeatureFlag')

Shortcut for the common case where only a single flag is checked. Same as `gate(flags => flags.enableFeatureFlag)`.

Normally I don't care about these types of conveniences but I'm about to add a lot more inline flag checks these all over our tests and it gets noisy. This helps a bit.

Changed files:
filename: scripts/babel/__tests__/transform-test-gate-pragma-test.js
patch: @@ -221,4 +221,8 @@ describe('dynamic gate method', () => {
   it('returns same conditions as pragma', () => {
     expect(gate(ctx => ctx.experimental && ctx.__DEV__)).toBe(true);
   });
+
+  it('converts string conditions to accessor function', () => {
+    expect(gate('experimental')).toBe(gate(flags => flags.experimental));
+  });
 });

filename: scripts/jest/setupTests.js
patch: @@ -205,8 +205,17 @@ if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
     }
   };
 
+  const coerceGateConditionToFunction = gateFnOrString => {
+    return typeof gateFnOrString === 'string'
+      ? // `gate('foo')` is treated as equivalent to `gate(flags => flags.foo)`
+        flags => flags[gateFnOrString]
+      : // Assume this is already a function
+        gateFnOrString;
+  };
+
   const gatedErrorMessage = 'Gated test was expected to fail, but it passed.';
-  global._test_gate = (gateFn, testName, callback, timeoutMS) => {
+  global._test_gate = (gateFnOrString, testName, callback, timeoutMS) => {
+    const gateFn = coerceGateConditionToFunction(gateFnOrString);
     let shouldPass;
     try {
       const flags = getTestFlags();
@@ -230,7 +239,8 @@ if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
         expectTestToFail(callback, error, timeoutMS));
     }
   };
-  global._test_gate_focus = (gateFn, testName, callback, timeoutMS) => {
+  global._test_gate_focus = (gateFnOrString, testName, callback, timeoutMS) => {
+    const gateFn = coerceGateConditionToFunction(gateFnOrString);
     let shouldPass;
     try {
       const flags = getTestFlags();
@@ -259,8 +269,9 @@ if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
   };
 
   // Dynamic version of @gate pragma
-  global.gate = fn => {
+  global.gate = gateFnOrString => {
+    const gateFn = coerceGateConditionToFunction(gateFnOrString);
     const flags = getTestFlags();
-    return fn(flags);
+    return gateFn(flags);
   };
 }
Repository: ollama/ollama
Pull request: types/structs: drop unused structs package


Changed files:
filename: types/structs/structs.go
patch: @@ -1,15 +0,0 @@
-// Copyright (c) Tailscale Inc & AUTHORS
-// SPDX-License-Identifier: BSD-3-Clause
-
-// Package structs contains the Incomparable type.
-package structs
-
-// Incomparable is a zero-width incomparable type. If added as the
-// first field in a struct, it marks that struct as not comparable
-// (can't do == or be a map key) and usually doesn't add any width to
-// the struct (unless the struct has only small fields).
-//
-// By making a struct incomparable, you can prevent misuse (prevent
-// people from using ==), but also you can shrink generated binaries,
-// as the compiler can omit equality funcs from the binary.
-type Incomparable [0]func()
Repository: nodejs/node
Pull request: tools: add sccache to `test-internet` workflow

Building `node` takes forever on that job, adding cache should speed it up.

<!--
Before submitting a pull request, please read:

- the CONTRIBUTING guide at https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md
- the commit message formatting guidelines at
  https://github.com/nodejs/node/blob/HEAD/doc/contributing/pull-requests.md#commit-message-guidelines

For code changes:
1. Include tests for any bug fixes or new features.
2. Update documentation if relevant.
3. Ensure that `make -j4 test` (UNIX), or `vcbuild test` (Windows) passes.

If you believe this PR should be highlighted in the Node.js CHANGELOG
please add the `notable-change` label.

Developer's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the best
    of my knowledge, is covered under an appropriate open source
    license and I have the right under that license to submit that
    work with modifications, whether created in whole or in part
    by me, under the same open source license (unless I am
    permitted to submit under a different license), as indicated
    in the file; or

(c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.

(d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including all
    personal information I submit with it, including my sign-off) is
    maintained indefinitely and may be redistributed consistent with
    this project or the open source license(s) involved.
-->


Changed files:
filename: .github/workflows/test-internet.yml
patch: @@ -34,8 +34,9 @@ env:
   PYTHON_VERSION: '3.12'
   FLAKY_TESTS: keep_retrying
   CLANG_VERSION: '19'
-  CC: clang-19
-  CXX: clang++-19
+  CC: sccache clang-19
+  CXX: sccache clang++-19
+  SCCACHE_GHA_ENABLED: 'true'
 
 permissions:
   contents: read
@@ -56,6 +57,10 @@ jobs:
         uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5.6.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
+      - name: Set up sccache
+        uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad  # v0.0.9
+        with:
+          version: v0.10.0
       - name: Environment Information
         run: npx envinfo
       - name: Build
Repository: denoland/deno
Pull request: fix(ext/node): initialize debuglog testEnabled with safe default

## Summary

- Initialize `testEnabled` and `debugImpls` in `debuglog.ts` with safe defaults (`() => false` and empty object) instead of leaving them deliberately uninitialized
- Fixes bootstrap crash `TypeError: testEnabled is not a function` that occurs when internal stream code triggers debug logging before `initializeDebugEnv()` has been called

This crash occurs when stdin is unavailable during Node process bootstrap — for example in compiled binaries run as Windows services (via nssm), or processes detached with `nohup`/`disown` on FreeBSD. In these cases, `initStdin()` creates a dummy Readable and calls `.push(null)`, which triggers `readableAddChunk` → `debug()` from the stream module's `debuglog("stream")`. If this happens before `initializeDebugEnv()` sets `testEnabled`, the process panics.

With this fix, early calls to `debuglog()` gracefully return a no-op logger instead of crashing. `initializeDebugEnv()` still overrides the defaults during normal bootstrap.

Closes #24208

## Test plan

- [x] Existing tests pass (`tools/format.js`, `tools/lint.js --js`)
- [ ] Verify on Windows with a compiled binary run as a service (nssm)
- [ ] Verify with `--watch` on a detached process (`nohup`/`disown`)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Changed files:
filename: ext/node/polyfills/internal/util/debuglog.ts
patch: @@ -4,10 +4,15 @@
 // TODO(petamoriken): enable prefer-primordials for node polyfills
 // deno-lint-ignore-file prefer-primordials
 
-// `debugImpls` and `testEnabled` are deliberately not initialized so any call
-// to `debuglog()` before `initializeDebugEnv()` is called will throw.
-let debugImpls: Record<string, (...args: unknown[]) => void>;
-let testEnabled: (str: string) => boolean;
+// `debugImpls` and `testEnabled` are initialized with safe defaults so that
+// calls to `debuglog()` before `initializeDebugEnv()` do not crash. This can
+// happen when internal stream code triggers debug logging during bootstrap
+// before the Node process is fully initialized (e.g. when stdin is unavailable
+// in compiled binaries run as Windows services or detached processes).
+let debugImpls: Record<string, (...args: unknown[]) => void> = Object.create(
+  null,
+);
+let testEnabled: (str: string) => boolean = () => false;
 
 // `debugEnv` is initial value of process.env.NODE_DEBUG
 export function initializeDebugEnv(debugEnv: string) {
Repository: huggingface/transformers
Pull request: [VisionEncoderDecoderModel] Update loss function

# What does this PR do?

Models like Donut are currently broken on main, they can't be fine-tuned. In order to unblock users at #39473, this PR reverts #36753.

It looks like the `ForCausalLMLoss` class shifts the labels, however the VisionEncoderDecoderModel class does not expect shifted labels as seen [here](https://github.com/huggingface/transformers/blob/d42e96a2a731c4a772e396baa0d915524c873ff0/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L547).

Changed files:
filename: src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py
patch: @@ -18,6 +18,7 @@
 
 import torch
 from torch import nn
+from torch.nn import CrossEntropyLoss
 
 from ...cache_utils import Cache
 from ...configuration_utils import PreTrainedConfig
@@ -374,9 +375,6 @@ def forward(
         ```"""
         return_dict = return_dict if return_dict is not None else self.config.use_return_dict
 
-        # num_items_in_batch is only needed for loss computation
-        num_items_in_batch = kwargs.pop("num_items_in_batch", None)
-
         kwargs_encoder = {argument: value for argument, value in kwargs.items() if not argument.startswith("decoder_")}
 
         kwargs_decoder = {
@@ -435,12 +433,8 @@ def forward(
         if labels is not None:
             logits = decoder_outputs.logits if return_dict else decoder_outputs[0]
 
-            loss = self.loss_function(
-                logits=logits,
-                labels=labels,
-                vocab_size=self.decoder.config.vocab_size,
-                num_items_in_batch=num_items_in_batch,
-            )
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(logits.reshape(-1, self.decoder.config.vocab_size), labels.reshape(-1))
 
         if not return_dict:
             if loss is not None:
Repository: vercel/next.js
Pull request: Fix flakey overlay feedback test

x-ref: https://github.com/vercel/next.js/actions/runs/18360376124/job/52302677520?pr=84500

Changed files:
filename: test/development/error-overlay/index.test.tsx
patch: @@ -1,5 +1,5 @@
 import { nextTestSetup } from 'e2e-utils'
-import { assertHasRedbox } from 'next-test-utils'
+import { assertHasRedbox, retry } from 'next-test-utils'
 
 describe('DevErrorOverlay', () => {
   const { next } = nextTestSetup({
@@ -33,15 +33,17 @@ describe('DevErrorOverlay', () => {
     await browser.elementByCss('button').click() // clicked "break on client"
     await browser.getByRole('button', { name: 'Mark as helpful' }).click()
 
-    expect(
-      await browser
-        .getByRole('region', { name: 'Error feedback' })
-        .getByRole('status')
-        .textContent()
-    ).toEqual('Thanks for your feedback!')
-    expect(feedbackRequests).toEqual([
-      '/__nextjs_error_feedback?errorCode=E794&wasHelpful=true',
-    ])
+    await retry(async () => {
+      expect(
+        await browser
+          .getByRole('region', { name: 'Error feedback' })
+          .getByRole('status')
+          .textContent()
+      ).toEqual('Thanks for your feedback!')
+      expect(feedbackRequests).toEqual([
+        '/__nextjs_error_feedback?errorCode=E794&wasHelpful=true',
+      ])
+    })
   })
 
   it('sends feedback when clicking not helpful button', async () => {
@@ -60,15 +62,17 @@ describe('DevErrorOverlay', () => {
     await browser.elementByCss('button').click() // clicked "break on client"
     await browser.getByRole('button', { name: 'Mark as not helpful' }).click()
 
-    expect(
-      await browser
-        .getByRole('region', { name: 'Error feedback' })
-        .getByRole('status')
-        .textContent()
-    ).toEqual('Thanks for your feedback!')
-    expect(feedbackRequests).toEqual([
-      '/__nextjs_error_feedback?errorCode=E794&wasHelpful=false',
-    ])
+    await retry(async () => {
+      expect(
+        await browser
+          .getByRole('region', { name: 'Error feedback' })
+          .getByRole('status')
+          .textContent()
+      ).toEqual('Thanks for your feedback!')
+      expect(feedbackRequests).toEqual([
+        '/__nextjs_error_feedback?errorCode=E794&wasHelpful=false',
+      ])
+    })
   })
 
   it('loads fonts successfully', async () => {