helloadhavan/github_issues huggingface dataset:
Repository: vuejs/vue
Pull request: fix(v-on): avoid events with empty keyCode (autocomplete)

<!--
Please make sure to read the Pull Request Guidelines:
https://github.com/vuejs/vue/blob/dev/.github/CONTRIBUTING.md#pull-request-guidelines
-->

<!-- PULL REQUEST TEMPLATE -->
<!-- (Update "[ ]" to "[x]" to check a box) -->

**What kind of change does this PR introduce?** (check at least one)

- [x] Bugfix
- [ ] Feature
- [ ] Code style update
- [ ] Refactor
- [ ] Build-related changes
- [ ] Other, please describe:

**Does this PR introduce a breaking change?** (check one)

- [ ] Yes
- [x] No

**The PR fulfills these requirements:**

- [x] It's submitted to the `dev` branch for v2.x (or to a previous version branch), _not_ the `master` branch
- [x] When resolving a specific issue, it's referenced in the PR's title (e.g. `fix #xxx[,#xxx]`, where "xxx" is the issue number)
- [x] All tests are passing: https://github.com/vuejs/vue/blob/dev/.github/CONTRIBUTING.md#development-setup
- [x] New/updated tests are included

**Other information:**

Chromium browsers (and Safari) trigger a `keydown`/`keyup` event on autocomplete. An `Event` object without `key` or `keyCode` is generated.
Vue, when listening with modifiers, is triggering the callback even if the modifier key doesn't match the `undefined` keyCode of the event.

Current behaviour: https://codepen.io/zupolgec/pen/RwWRxdK
New behaviour: https://codepen.io/zupolgec/pen/qBONxMj

Try autocompleting the first field: in the first demo is counted, in the second demo is ignored.

See also same kind of issue on another JS library: https://github.com/alpinejs/alpine/pull/389#issuecomment-615935688

Changed files:
filename: src/core/instance/render-helpers/check-keycodes.js
patch: @@ -31,4 +31,5 @@ export function checkKeyCodes (
   } else if (eventKeyName) {
     return hyphenate(eventKeyName) !== key
   }
+  return eventKeyCode === undefined
 }

filename: test/unit/features/directives/on.spec.js
patch: @@ -976,6 +976,17 @@ describe('Directive v-on', () => {
     expect(value).toBe(1)
   })
 
+  it('should not execute callback if modifiers are present', () => {
+    vm = new Vue({
+      el,
+      template: '<input @keyup.?="foo">',
+      methods: { foo: spy }
+    })
+    // simulating autocomplete event (Event object with type keyup but without keyCode)
+    triggerEvent(vm.$el, 'keyup')
+    expect(spy.calls.count()).toBe(0)
+  })
+
   describe('dynamic arguments', () => {
     it('basic', done => {
       const spy = jasmine.createSpy()
Repository: huggingface/transformers
Pull request: custom tok init fix

custom tokenizers fail on super._init_() call that tries to update vocab size before all vocab attrs are defined


Changed files:
filename: src/transformers/tokenization_python.py
patch: @@ -415,6 +415,9 @@ def __init__(self, **kwargs):
 
         self.tokens_trie = Trie()
 
+        # Initialize total_vocab_size early to avoid issues if get_vocab() is called early (custom tokenizers)
+        self.total_vocab_size = 0
+
         # 2. init `_added_tokens_decoder` if child class did not
         if not hasattr(self, "_added_tokens_decoder"):
             self._added_tokens_decoder: dict[int, AddedToken] = {}
@@ -439,17 +442,13 @@ def __init__(self, **kwargs):
         # 7. init the parent class
         super().__init__(**kwargs)
 
-        if self._added_tokens_decoder:
-            self._update_total_vocab_size()
-
         # 4. If some of the special tokens are not part of the vocab, we add them, at the end.
         # V5: the order of addition follows self.SPECIAL_TOKENS_ATTRIBUTES, then extra special tokens
         # Note: _add_tokens will automatically skip tokens that are already in the base vocab
         self._add_tokens(
             [token for token in self.all_special_tokens if token not in self._added_tokens_encoder],
             special_tokens=True,
         )
-        self._update_total_vocab_size()
 
     @property
     def is_fast(self) -> bool:
@@ -501,6 +500,9 @@ def __len__(self):
         """
         Size of the full vocabulary with the added tokens.
         """
+        # Lazy evaluation: compute if not already set (e.g., during initialization)
+        if self.total_vocab_size == 0:
+            self._update_total_vocab_size()
         return self.total_vocab_size
 
     def _update_total_vocab_size(self):

filename: tests/models/auto/test_tokenization_auto.py
patch: @@ -33,6 +33,7 @@
     GPT2Tokenizer,
     HerbertTokenizer,
     PreTrainedTokenizerFast,
+    PythonBackend,
     Qwen2Tokenizer,
     Qwen2TokenizerFast,
     Qwen3MoeConfig,
@@ -458,6 +459,14 @@ def test_from_pretrained_dynamic_tokenizer(self):
         self.assertIsNot(tokenizer.__class__, reloaded_tokenizer.__class__)
         self.assertTrue(reloaded_tokenizer.special_attribute_present)
 
+    @slow
+    def test_custom_tokenizer_init(self):
+        tokenizer = AutoTokenizer.from_pretrained(
+            "Qwen/Qwen-VL", trust_remote_code=True, revision="0547ed36a86561e2e42fecec8fd0c4f6953e33c4"
+        )
+        self.assertIsInstance(tokenizer, PythonBackend)
+        self.assertGreater(len(tokenizer.get_vocab()), 0)
+
     @require_tokenizers
     def test_from_pretrained_dynamic_tokenizer_conflict(self):
         class NewTokenizer(BertTokenizer):
Repository: facebook/react
Pull request: [DevTools] Fix missing key warning

Follow-up to https://github.com/facebook/react/pull/34130

Changed files:
filename: packages/react-devtools-shared/src/devtools/views/Components/InspectedElementView.js
patch: @@ -174,9 +174,8 @@ export default function InspectedElementView({
             {showStack ? <StackTraceView stack={stack} /> : null}
             {showOwnersList &&
               owners?.map(owner => (
-                <>
+                <Fragment key={owner.id}>
                   <OwnerView
-                    key={owner.id}
                     displayName={owner.displayName || 'Anonymous'}
                     hocDisplayNames={owner.hocDisplayNames}
                     environmentName={
@@ -190,7 +189,7 @@ export default function InspectedElementView({
                   {owner.stack != null && owner.stack.length > 0 ? (
                     <StackTraceView stack={owner.stack} />
                   ) : null}
-                </>
+                </Fragment>
               ))}
 
             {rootType !== null && (
Repository: ollama/ollama
Pull request: sched: fix runner leak during reloading unload

When the same model is being reloaded rapidly with client connections being canceled before the model finishes loading, the queued unload event could cause a leak of runners by deleting a different runner from the loaded list.

Fixes #10433 

Changed files:
filename: server/sched.go
patch: @@ -387,6 +387,17 @@ func (s *Scheduler) processCompleted(ctx context.Context) {
 				s.loadedMu.Unlock()
 				runner.refMu.Unlock()
 				slog.Debug("duplicate expired event, ignoring", "runner", runner)
+			} else if runner.pid != runnerToUnload.pid {
+				// If the pids do not match, we likely had multiple load
+				// failures for the same model in quick succession due to
+				// request context canceled and are draining the queue of
+				// events. Ensure the orphaned runner is properly shut down, but
+				// do not delete the mismatched loaded runner, or wait for VRAM
+				// convergence.
+				slog.Debug("orphaned runner shutting down", "orphan", runner, "loaded", runnerToUnload)
+				runner.unload()
+				s.loadedMu.Unlock()
+				runner.refMu.Unlock()
 			} else {
 				slog.Debug("starting background wait for VRAM recovery", "runner", runner)
 				finished := runner.waitForVRAMRecovery()
Repository: facebook/react
Pull request: [DevTools] Fix index

I used the wrong indexer and tested with one entry.


Changed files:
filename: packages/react-devtools-shared/src/backend/fiber/renderer.js
patch: @@ -3247,7 +3247,7 @@ export function attach(
       const debugInfo = thenable._debugInfo;
       if (debugInfo) {
         for (let j = 0; j < debugInfo.length; j++) {
-          const debugEntry = debugInfo[i];
+          const debugEntry = debugInfo[j];
           if (debugEntry.awaited) {
             const asyncInfo: ReactAsyncInfo = (debugEntry: any);
             insertSuspendedBy(asyncInfo);
Repository: nodejs/node
Pull request: process: do not truncate long strings in `--print`

Fixes: https://github.com/nodejs/node/issues/61337

<!--
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: lib/internal/process/execution.js
patch: @@ -455,8 +455,12 @@ function runScriptInContext(name, body, breakFirstLine, print, module, baseUrl,
   if (print) {
     const { log } = require('internal/console/global');
 
-    process.on('exit', () => {
-      log(result);
+    const printResult = () => log(result);
+
+    process.on('exit', printResult);
+    process.once('beforeExit', () => {
+      printResult();
+      process.off('exit', printResult);
     });
   }
   if (origModule !== undefined)

filename: test/parallel/test-cli-eval.js
patch: @@ -115,6 +115,12 @@ child.exec(...common.escapePOSIXShell`"${process.execPath}" -p "\\-42"`, common.
   assert.strictEqual(stderr, '');
 }));
 
+// Long output should not be truncated.
+child.exec(...common.escapePOSIXShell`"${process.execPath}" -p "'1'.repeat(1e5)"`, common.mustSucceed((stdout, stderr) => {
+  assert.strictEqual(stdout, `${'1'.repeat(1e5)}\n`);
+  assert.strictEqual(stderr, '');
+}));
+
 child.exec(...common.escapePOSIXShell`"${process.execPath}" --use-strict -p process.execArgv`,
            common.mustSucceed((stdout, stderr) => {
              assert.strictEqual(
Repository: ggml-org/llama.cpp
Pull request: CUDA: fix BF16 FA compilation

See https://github.com/ggml-org/llama.cpp/pull/20525#issuecomment-4106067370 .

Changed files:
filename: ggml/src/ggml-cuda/convert.cuh
patch: @@ -42,11 +42,15 @@ template<typename dst_t, typename src_t>
     } else if constexpr(std::is_same_v<src_t, float2> && std::is_same_v<dst_t, half2>) {
         return __float22half2_rn(x);
     } else if constexpr(std::is_same_v<src_t, nv_bfloat162> && std::is_same_v<dst_t, float2>) {
-#if !defined(GGML_USE_HIP) && defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+#ifdef GGML_USE_HIP
+        return make_float2(__bfloat162float(__low2bfloat16(x)), __bfloat162float(__high2bfloat16(x)));
+#else
+#if __CUDA_ARCH__ >= 800
         return __bfloat1622float2(x);
 #else
-        return make_float2(__bfloat162float(__low2bfloat16(x)), __bfloat162float(__high2bfloat16(x)));
-#endif // !defined(GGML_USE_HIP) && defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+        return make_float2(__bfloat162float(x.x), __bfloat162float(x.y));
+#endif // __CUDA_ARCH__ >= 800
+#endif // GGML_USE_HIP
     } else if constexpr(std::is_same_v<src_t, float2> && std::is_same_v<dst_t, nv_bfloat162>) {
         // bypass compile error on cuda 12.0.1
 #ifdef GGML_USE_HIP
Repository: huggingface/transformers
Pull request: Cast byte_count to int in caching_allocator_warmup for MPS compatibility

…tibility

# What does this PR do?

Fixes #43582

Fixes TypeError on Apple Silicon (MPS) when loading models with quantization by ensuring `byte_count // 2` returns a Python int.

## The Issue

On line 4762 in `modeling_utils.py`, `torch.empty(byte_count // 2, ...)` fails with TypeError on MPS devices because:
1. `byte_count` comes from `total_byte_count` as a torch/numpy scalar
2. For CUDA/XPU: line 4760 casts it to Python int
3. For MPS: this casting is skipped (device type check on line 4748 doesn't include "mps")
4. `byte_count // 2` on a torch scalar returns float
5. `torch.empty()` expects int, receives float → TypeError

## The Fix

Wrap the division in `int()` on line 4762:
```python
_ = torch.empty(int(byte_count // 2), dtype=torch.float16, device=device, requires_grad=False)
```

This defensive fix works for all device types (CUDA, XPU, MPS, and future additions).

## Testing

**Reproduced on main branch:**
- Loading GPT-2 with BitsAndBytes 4-bit quantization on MPS → TypeError

**Verified fix works:**
- Same setup with fix → Model loads successfully without error

Tested on Apple Silicon M3 Pro with PyTorch 2.10.0.

## Before submitting
- [x] This PR fixes a bug
- [x] Tested on actual hardware (M3 Pro MPS)
- [x] Code follows existing patterns

cc @vasqu @Cyrilvallez

Changed files:
filename: src/transformers/modeling_utils.py
patch: @@ -4728,7 +4728,7 @@ def caching_allocator_warmup(model: PreTrainedModel, expanded_device_map: dict,
             ) - torch_accelerator_module.memory_allocated(index)
             byte_count = int(max(0, byte_count - unused_memory))
         # We divide by 2 here as we allocate in fp16
-        _ = torch.empty(byte_count // 2, dtype=torch.float16, device=device, requires_grad=False)
+        _ = torch.empty(int(byte_count // 2), dtype=torch.float16, device=device, requires_grad=False)
 
 
 class AttentionInterface(GeneralInterface):
Repository: vuejs/vue
Pull request: fix: force update between two components with and without slot

<!--
Please make sure to read the Pull Request Guidelines:
https://github.com/vuejs/vue/blob/dev/.github/CONTRIBUTING.md#pull-request-guidelines
-->

<!-- PULL REQUEST TEMPLATE -->
<!-- (Update "[ ]" to "[x]" to check a box) -->

**What kind of change does this PR introduce?** (check at least one)

- [x] Bugfix
- [ ] Feature
- [ ] Code style update
- [ ] Refactor
- [ ] Build-related changes
- [ ] Other, please describe:

**Does this PR introduce a breaking change?** (check one)

- [ ] Yes
- [x] No

If yes, please describe the impact and migration path for existing applications:

**The PR fulfills these requirements:**

- [x] It's submitted to the `dev` branch for v2.x (or to a previous version branch), _not_ the `master` branch
- [x] When resolving a specific issue, it's referenced in the PR's title (e.g. `fix #xxx[,#xxx]`, where "xxx" is the issue number)
- [x] All tests are passing: https://github.com/vuejs/vue/blob/dev/.github/CONTRIBUTING.md#development-setup
- [x] New/updated tests are included

If adding a **new feature**, the PR's description includes:
- [ ] A convincing reason for adding this feature (to avoid wasting your time, it's best to open a suggestion issue first and wait for approval before working on it)

**Other information:**
fix #11652

Changed files:
filename: src/core/instance/lifecycle.js
patch: @@ -234,7 +234,8 @@ export function updateChildComponent (
   const hasDynamicScopedSlot = !!(
     (newScopedSlots && !newScopedSlots.$stable) ||
     (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
+    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+    (!newScopedSlots && vm.$scopedSlots.$key)
   )
 
   // Any static slot children from the parent may have changed during parent's

filename: test/unit/features/component/component-scoped-slot.spec.js
patch: @@ -1325,4 +1325,28 @@ describe('Component scoped slot', () => {
       expect(vm.$el.textContent).toMatch(`1`)
     }).then(done)
   })
+
+  // #11652
+  it('should update when swtching between two components with slot and without slot', done => {
+    const Child = {
+      template: `<div><slot/></div>`
+    }
+
+    const parent = new Vue({
+      template: `<div>
+        <child v-if="flag"><template #default>foo</template></child>
+        <child v-else></child>
+      </div>`,
+      data: {
+        flag: true
+      },
+      components: { Child }
+    }).$mount()
+
+    expect(parent.$el.textContent).toMatch(`foo`)
+    parent.flag=false
+    waitForUpdate(()=>{
+      expect(parent.$el.textContent).toMatch(``)
+    }).then(done)
+  })
 })
Repository: ollama/ollama
Pull request: server: improve tensor quantization fallback logic

Fall back to alternative quantization types when a tensor's dimensions aren't divisible by the block size required for the original desired quantization type. If retried quantization types fail, the system ultimately falls back to F16 (half-precision floating point) which has a block size of 1 and can handle any tensor dimension.

resolves #10729

Changed files:
filename: server/quantization.go
patch: @@ -120,14 +120,30 @@ func getTensorNewType(kv fsggml.KV, qs *quantizeState, newType fsggml.TensorType
 
 	if newType.IsQuantized() {
 		nx := shape[0]
-		ny := uint64(1)
-		if len(shape) > 1 {
-			ny = shape[1]
-		}
 		qk_k := newType.BlockSize()
+
+		// Check if first dimension is divisible by block size
 		if nx%qk_k != 0 {
-			slog.Warn(fmt.Sprintf("tensor cols %d x %d are not divisible by %d, required for %s.  Falling back to quantization %s", nx, ny, qk_k, newType.String(), fsggml.TensorTypeF16.String()))
-			newType = fsggml.TensorTypeF16
+			// Store the original type for logging
+			originalType := newType
+
+			// Select appropriate fallback based on original type
+			switch newType {
+			case fsggml.TensorTypeQ4_K:
+				newType = fsggml.TensorTypeQ5_0
+			case fsggml.TensorTypeQ5_K:
+				newType = fsggml.TensorTypeQ5_1
+			case fsggml.TensorTypeQ6_K:
+				newType = fsggml.TensorTypeQ8_0
+			}
+
+			// Final check - if still incompatible, fall back to F16
+			if nx%newType.BlockSize() != 0 {
+				newType = fsggml.TensorTypeF16
+			}
+
+			slog.Warn(fmt.Sprintf("tensor cols %d are not divisible by %d, required for %s - using fallback quantization %s",
+				nx, qk_k, originalType.String(), newType.String()))
 		}
 	}
 	return newType
Repository: ggml-org/llama.cpp
Pull request: server: fix Host header

Host header should include port when it's not default.


Changed files:
filename: tools/server/server-models.cpp
patch: @@ -1181,7 +1181,8 @@ server_http_proxy::server_http_proxy(
                 continue;
             }
             if (key == "Host" || key == "host") {
-                req.set_header(key, host);
+                bool is_default_port = (scheme == "https" && port == 443) || (scheme == "http" && port == 80);
+                req.set_header(key, is_default_port ? host : host + ":" + std::to_string(port));
             } else {
                 req.set_header(key, value);
             }
Repository: vuejs/vue
Pull request: fix(compiler): avoid converting &nbps; to spaces

The regex for whitespace was too strict and was causing $nbps; chars to
disappear from templates when `whitespace: 'condense'` is set. Changing the rule
to avoid converting non-breaking white space chars into regular spaces.

Fixes #10485
Fixes #11059

**What kind of change does this PR introduce?** (check at least one)

- [x] Bugfix
- [ ] Feature
- [ ] Code style update
- [ ] Refactor
- [ ] Build-related changes
- [ ] Other, please describe:

**Does this PR introduce a breaking change?** (check one)

- [ ] Yes
- [x] No

If yes, please describe the impact and migration path for existing applications:

**The PR fulfills these requirements:**

- [x] It's submitted to the `dev` branch for v2.x (or to a previous version branch), _not_ the `master` branch
- [x] When resolving a specific issue, it's referenced in the PR's title (e.g. `fix #xxx[,#xxx]`, where "xxx" is the issue number)
- [x] All tests are passing: https://github.com/vuejs/vue/blob/dev/.github/CONTRIBUTING.md#development-setup
- [x] New/updated tests are included


Changed files:
filename: src/compiler/parser/index.js
patch: @@ -38,7 +38,7 @@ const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
 const slotRE = /^v-slot(:|$)|^#/
 
 const lineBreakRE = /[\r\n]/
-const whitespaceRE = /\s+/g
+const whitespaceRE = /[ \f\t\r\n]+/g
 
 const invalidAttributeRE = /[\s"'<>\/=]/
 

filename: test/unit/modules/compiler/parser.spec.js
patch: @@ -865,6 +865,14 @@ describe('parser', () => {
     expect(ast.children[4].children[0].text).toBe('. Have fun! ')
   })
 
+  it(`maintains &nbsp; with whitespace: 'condense'`, () => {
+    const options = extend({}, condenseOptions)
+    const ast = parse('<span>&nbsp;</span>', options)
+    const code = ast.children[0]
+    expect(code.type).toBe(3)
+    expect(code.text).toBe('\xA0')
+  })
+
   it(`preserve whitespace in <pre> tag with whitespace: 'condense'`, function () {
     const options = extend({}, condenseOptions)
     const ast = parse('<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>', options)
Repository: ggml-org/llama.cpp
Pull request: [SYCL] Support bf16 and quantized type of MUL_MAT

Fix issue: https://github.com/ggml-org/llama.cpp/issues/20713

Enable BF16 and quantized type of MUL_MAT.
All related UT cases are passed on Arc770 and UHD Graphics 770  of 13700K.

Changed files:
filename: ggml/src/ggml-sycl/ggml-sycl.cpp
patch: @@ -4667,22 +4667,8 @@ static bool ggml_backend_sycl_device_supports_op(ggml_backend_dev_t dev, const g
                 if (a->ne[3] != b->ne[3]) {
                     return false;
                 }
-                ggml_type a_type = a->type;
-                if (a_type == GGML_TYPE_IQ4_NL  || a_type == GGML_TYPE_IQ4_XS ||
-                    a_type == GGML_TYPE_IQ3_XXS || a_type == GGML_TYPE_IQ3_S  ||
-                    a_type == GGML_TYPE_IQ2_XXS || a_type == GGML_TYPE_IQ2_XS || a_type == GGML_TYPE_IQ2_S ||
-                    a_type == GGML_TYPE_IQ1_S || a_type == GGML_TYPE_IQ1_M
-                    ) {
-                    if (b->ne[1] == 1 && ggml_nrows(b) > 1) {
-                        return false;
-                    }
-                }
+
                 ggml_type src0_type = op->src[0]->type;
-                if (src0_type == GGML_TYPE_BF16 ) {
-                    // TODO: support GGML_TYPE_BF16
-                    // FIXME: keep a list of supported types to avoid breaking the backend when a new type is added
-                    return false;
-                }
 
                 // TODO: The configuration below needs more work to be supported with oneDNN
                 if (ggml_is_permuted(a) && !ggml_is_contiguous(a) &&
Repository: ollama/ollama
Pull request: integration: add qwen2.5-vl

Replace the older llava model with qwen2.5 for vision tests 
Skip split-batch test on small VRAM systems to avoid excessive test time

Changed files:
filename: integration/llm_image_test.go
patch: @@ -19,7 +19,7 @@ func TestVisionModels(t *testing.T) {
 	}
 	testCases := []testCase{
 		{
-			model: "llava:7b",
+			model: "qwen2.5vl",
 		},
 		{
 			model: "llama3.2-vision",
@@ -60,6 +60,7 @@ func TestVisionModels(t *testing.T) {
 }
 
 func TestIntegrationSplitBatch(t *testing.T) {
+	skipUnderMinVRAM(t, 6)
 	image, err := base64.StdEncoding.DecodeString(imageEncoding)
 	require.NoError(t, err)
 	req := api.GenerateRequest{