sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: godot
Issue: Mouse Force Pass Scroll Events is not working on Emulate Touch from Mouse
Labels: bug,needs testing,topic:input,topic:gui

### Tested versions

Reproducible in: v4.2.1.stable.mono.official [b09f793f5], v4.3.beta2.mono.official [b75f0485b]

### System information

Godot v4.3.beta2.mono - Windows 10.0.19045 - Vulkan (Forward+) - dedicated NVIDIA GeForce GTX 1650 (NVIDIA; 31.0.15.3114) - Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz (12 Threads)

### Issue description

mouse_force_pass_scroll_events seems not working. As far as I understand, [mouse_force_pass_scroll_events](https://docs.godotengine.org/en/stable/classes/class_control.html#class-control-property-mouse-force-pass-scroll-events) should force mouse filter Pass to its parent even if it set to stop so that the scroll container can scroll.

### Steps to reproduce

I enabled emulate_touch_from_mouse before testing it. I used ScrollContainer, followed by VBoxContainer and fill it with ColorRect to test it. During Enabling mouse_force_pass_scroll_events while putting stop on mouse_filter, scrolling with mouse drag does nothing, except for the small gap between the ColorRects. As a reference for my own, I set pass on mouse_filter and it works fine.

### Minimal reproduction project (MRP)

[scrollcontainer.zip](https://github.com/user-attachments/files/16146624/scrollcontainer.zip)

Edit:
I've done a little bit more testing on android (for Godot v4.2.1) with both enabling/disabling emulate_mouse_from_touch. During Enabling mouse_force_pass_scroll_events while putting stop on mouse_filter, it gives similar result. As another reference for my own, I set pass on mouse_filter and it works fine, but doesn't work when I disabled emulate_mouse_from_touch.
Repository: rust
Issue: Mismatched types for a conditional containing closures inside method call
Labels: A-closures,C-bug,T-types

Hello! I have encountered an issue when using a conditional returning closures inside a method call - specifically, the compiler is unable to coerce closure types to `Box<dyn Fn(...)->...>` for a very specific case. Consider this code.
```rust
trait Foo<I : Fn() -> i16>{
    fn foo(&self, param : I) -> ();
}
struct S {}

impl Foo<Box<dyn Fn() -> i16>> for S {
    fn foo(&self, param : Box<dyn Fn() -> i16>) -> () {
        unimplemented!();
    }
}

fn main() {
    let s = S {};
    
    let cond = true;
    s.foo(if cond { //replace cond with cond==true
        Box::new(|| {42})
    }
    else {
        Box::new(|| {42})
    });
}
```

The above code does not compile, with an error message saying that `if` and `else` have incompatible types. **When `cond` is replaced with `cond==true`, the code will compile.**

This issue is very similar to an issue I submitted a while back (#126988). But only now have I found that the compiler behaves differently for different conditionals.

Also, when you enclose the type of param in another type, for example Vec, the code will compile even with just `cond` if-statement conditional. See adjusted code below that compiles:
```rust
trait Foo<I : Fn() -> i16>{
    fn foo(&self, param : Vec<I>) -> ();
}
struct S {}

impl Foo<Box<dyn Fn() -> i16>> for S {
    fn foo(&self, param : Vec<Box<dyn Fn() -> i16>>) -> () {
        unimplemented!();
    }
}

fn main() {
    let s = S {};
    
    let cond = true;
    s.foo(if cond {
        vec![if cond {Box::new(|| {42})} else {Box::new(|| {43})}]
    }
    else {
        vec![Box::new(|| {42})]
    });
}
```


### Meta
<!--
If you're using the stable version of the compiler, you should also check if the
bug also exists in the beta or nightly versions.
-->


```
rustc 1.75.0 (82e1608df 2023-12-21)
release: 1.75.0
LLVM version: 17.0.6
```


</p>
</details>
Repository: pytorch
Issue: Rescale to zero torch.nn.CrossEntropyLoss with label_smoothing > 0
Labels: module: nn,triaged

### 🚀 The feature, motivation and pitch

Currently, the cross entropy loss using `label_smoothing > 0` does not reach its minimum when the loss is zero. This can become problematic when you try to compare two models with different `label_smoothing` using the loss values. It is also quite tricky when the model converges well because we can't measure the convergence using the logarithm of the loss.

Instead, the minimum is given by
$$-(1 - \alpha) \log(1-\alpha) - \alpha (\log(\alpha) - \log(K-1)),$$
where $\alpha$ is `label_smoothing` and $K$ is the total number of classes.

For $\alpha=0.1$ and $K=1000$, the minimum is equal to approximatively $4.4 \times 10^{-1}$.

### Alternatives

Practitioners can fix this problem themselves by defining a new CrossEntropyLoss and rescaling the loss themselves. 

### Additional context

_No response_

cc @albanD @mruberry @jbschlosser @walterddr @mikaylagawarecki
Repository: rust
Issue: Tracking Issue for `once_wait`
Labels: T-libs-api,final-comment-period,C-tracking-issue,disposition-merge

Feature gate: `#![feature(once_wait)]`

This is a tracking issue for adding a blocking `.wait()` method on `Once` and `OnceLock`, to allow other threads to synchronize on their completion. This will provide the same interface as `once_cell`'s [`OnceCell::wait`](https://docs.rs/once_cell/latest/once_cell/sync/struct.OnceCell.html#method.wait).

### Public API

```rust
impl Once {
    /// Block the current thread until the `Once` has been initialized.
    fn wait(&self);
    /// Block the current thread until the `Once` has been initialized, ignoring poisoning.
    fn wait_force(&self);
}

impl OnceLock {
    /// Block the current thread until the value is set, then return it.
    fn wait(&self) -> &T;
}
```

### Steps / History

- [x] ACP: https://github.com/rust-lang/libs-team/issues/405
- [x] Implementation: #127567 
- [ ] Final comment period (FCP)[^1]
- [ ] Stabilization PR

### Unresolved Questions

- Async API (proposed in the ACP): naming, how it works, interaction with other synchronization primitives since e.g. `Mutex` does not have async methods. This would probably get its own feature gate.

[^1]: https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html
Repository: pytorch
Issue: Provide shutdown() method for ProcessGroupGloo distributed backend
Labels: triage review,oncall: distributed,enhancement

### 🚀 The feature, motivation and pitch

Many training codebases (e.g. https://github.com/NVIDIA/Megatron-LM) use both NCCL and GLOO distributed backends in the same large-scale training run. Currently it's possible to call `torch.distributed.destroy_process_group()` to terminate pending NCCL kernels if a failure is observed on some distributed ranks, but there is no method equivalent to `ProcessGroupNCCL.shutdown()` in the GLOO backend, and the training run needs to rely on timeouts to recover from crashes, which is inefficient.

A request is to add `ProcessGroupGloo.shutdown()` method, to bring feature parity with `ProcessGroupNCCL.shutdown()` and to enable `torch.distributed.destroy_process_group()` to terminate pending operations for CPU and GPU distributed backends  in order to enable faster recovery from distributed rank failures.

### Alternatives

_No response_

### Additional context

_No response_

cc @mrshenli @pritamdamania87 @zhaojuanmao @satgera @gqchen @aazzolini @osalpekar @jiayisuse @H-Huang @kwen2501 @awgu @fegin @XilunWu @wanchaol @fduwjj @wz337 @wconstab @chauhang @d4l3k
Repository: node
Issue: Support .noderc or similar file-based initialization configurations?
Labels: cli

In https://github.com/nodejs/node/issues/52219 it was mentioned that for APM use cases it would be nice to have a way to register loaders without using command line flags. It occurred to me maybe what we need is an initialization config similar to the rc files out there for various applications.

For example in my `.lldbinit` I have these that extend LLDB to help me debug

```
plugin load /path/to/llnode.dylib
command script import /path/to/lldb_commands.py
```

It seems this is serving the same use case as the Node.js loader registration - run some scripts or register some plugin to Node.js before you actually start running it.

For loading loaders, I guess we can support something like a `.noderc` that is discovered when users start running Node.js, or make that part of `package.json`, which allows registering certain hooks before the actual application code is run. For example in the case of package.json, I guess the project pacakge.json would include something like this:

```
{
  "preload": [
     "apm-package/register"
   ],
  "dependencies": {
    "apm-package": "1.1.1"
  }
}
```

If we want something more flexible than "just loading some scripts" though, I guess a dedicated rc file would be easier to use than package.json.

cc @timfish @nodejs/loaders
Repository: flutter
Issue: double selection on TextFormField 
Labels: a: text input,platform-web,has reproducible steps,P2,browser: safari-ios,team-web,triaged-web,fyi-text-input,found in release: 3.22,found in release: 3.24

![WhatsApp Image 2024-07-09 at 11 06 08](https://github.com/flutter/flutter/assets/12328631/5f436d58-cc35-4d59-bd17-2b22bc7e3aa3)
### Steps to reproduce

1. run the code attached on mobile web -> flutter run -d web-server --web-port 3000 --web-hostname 0.0.0.0

2. type some text in the text field 

3. select it with double tap

### Expected results

see text selection with one color 

### Actual results

- two colors when selecting 
- one of the selection part shifted to another place 
 
Notes:
* only occurs in mobile-web
* when using not multiline the double selection appears on the text (two colors selection)


### Code sample

<details open><summary>Code sample</summary>

```dart

class MyApp extends StatefulWidget {
  
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final TextEditingController _controller = TextEditingController();

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: Scaffold(
        body: TextFormField(
          controller: _controller,
          maxLines: 5,
          maxLength: 1000,
          keyboardType: TextInputType.multiline,
        )
      ),
    );
  }
}
```

</details>


### Screenshots or Video

<details open>
<summary>Screenshots / Video demonstration</summary>

[Upload media here]

</details>


### Logs

<details open><summary>Logs</summary>

```console
[Paste your logs here]
```

</details>


### Flutter Doctor output

<details open><summary>Doctor output</summary>

```console
[Paste your output here]
```

</details>
Repository: neovim
Issue: wait for UI when launching with --listen (without --embed)
Labels: enhancement,ui,server,has:plan,startup

### Problem

Currently you can launch a remote server with `--headless --listen addr:port`, and later connect an UI like Neovide to it, which is good. But the problem is that Neovim does not wait for the UI to attach and proceeds to load the init files immediately. This is problematic because the user might have conditional customization in the init files, for example `if vim.g.neovide`, which will never run.

We, the maintainers of Neovide, have always assumed that `--headless` waits for the UI to attach, so that's what we have been suggesting in the documentation. But as part of investigating bugs like https://github.com/neovide/neovide/issues/2620, https://github.com/neovide/neovide/issues/1868 I found that to not be the case. It's also not a bug, since the behaviour is clearly documented in the documentation (but not the commandline help).

https://github.com/neovim/neovim/pull/25709 (Neovim 0.10) added support for `--embed --listen addr:port`, which waits for the UI to attach. But that is only suitable as a workaround at best, since it also captures the stdin. Another hacky workaround is to do the GUI specific configuration in `UIEnter`, but that's too late due to https://github.com/neovim/neovim/issues/25377, and things like font's should definitely be set before anything is drawn on the screen.


### Expected behavior

Preferably `--headless --listen addr:port`, should always wait for an UI to attach, at least I can't think of any use cases for the current behavour. 

But if that's not possible, a new command line parameter should be added to make the startup wait for an UI to attach.
Repository: node
Issue: skipFiles does not suppress "uncaught" exceptions in web streams
Labels: debugger

### Version

22.4.1

### Platform

```text
Microsoft Windows NT 10.0.22635.0 x64
```


### Subsystem

_No response_

### What steps will reproduce the bug?

Run this code in the VSCode debugger with `"skipFiles":["<node_internals>/**"]` in the launch configuration.

```
import net from 'node:net';
import stream from 'node:stream';
const socket = net.connect('http://host.invalid.');
socket.on('error', (e) => {
   console.error('Caught the error', e.message);
});
let myStream = stream.Duplex.toWeb(socket);

setTimeout(() => {
   console.log('done');
}, 1000);
```

### How often does it reproduce? Is there a required condition?

_No response_

### What is the expected behavior? Why is that the expected behavior?

It is expected that the debugger won't trip. This promise rejection is entirely created and handled within node's internals and should be suppressed by the VSCode's `skipFiles` filter.

### What do you see instead?

The debugger breaks when the promise is rejected.

The trace (given by `console.trace`) when it is rejected looks like:
```
Trace
    at eval (eval-7c2224bb.repl:1:9)
    at Object.reject (<anonymous>)
    at writableStreamRejectCloseAndClosedPromiseIfNeeded (node:internal/webstreams/writablestream:771:28)
    at writableStreamFinishErroring (node:internal/webstreams/writablestream:903:5)
    at writableStreamStartErroring (node:internal/webstreams/writablestream:755:5)
    at writableStreamDefaultControllerError (node:internal/webstreams/writablestream:1202:3)
    at WritableStreamDefaultController.error (node:internal/webstreams/writablestream:502:5)
    at Socket.<anonymous> (node:internal/webstreams/adapters:195:18)
    at Socket.<anonymous> (node:internal/util:538:20)
    at Socket.onclose (node:internal/streams/end-of-stream:152:25)
```

The stack on the error object is:
```
'AbortError: The operation was aborted
    at handleKnownInternalErrors (node:internal/webstreams/adapters:111:14)
    at Socket.<anonymous> (node:internal/webstreams/adapters:179:13)
    at Socket.<anonymous> (node:internal/util:538:20)
    at Socket.onclose (node:internal/streams/end-of-stream:152:25)
    at Socket.emit (node:events:532:35)
    at Pipe.<anonymous> (node:net:339:12)
    at Pipe.callbackTrampoline (node:internal/async_hooks:130:17)'
```
![Screenshot 2024-07-09 133433](https://github.com/nodejs/node/assets/119948/b33c379f-cae9-4573-bfa1-69c55e25ff74)

### Additional information

_No response_
Repository: kubernetes
Issue: Remove gitRepo volume type
Labels: priority/critical-urgent,area/security,sig/storage,kind/feature,sig/security,needs-triage

### What would you like to be added?

I'd like to remove gitRepo volume types. It's been deprecated for 6 years now and if a giant foot gun. 

In a recent blog a researcher has exploited it to get remote code execution(RCE). 

https://irsl.medium.com/sneaky-write-hook-git-clone-to-root-on-k8s-node-e38236205d54


### Why is this needed?

To prevent folks from using a deprecated and dangerous volume type.
Repository: flutter
Issue: [pigeon][swift 6]use typed throw for swift codegen 
Labels: platform-ios,package,p: pigeon,P3,team-ios,triaged-ios

Swift 6 introduces ["typed throws"](https://github.com/swiftlang/swift-evolution/blob/main/proposals/0413-typed-throws.md): 

```
func foo() throws(MyError) { … }

do { 
  try foo()
} catch { 
  // error here is of type MyError (rather than of type `Error`)
}
```

A good way to force developers to throw `PigeonError`. 

Only available for Swift 6 though, so will need to fix all the concurrency warnings before we can use it.
Repository: ollama
Issue: Force ollama to use GPU
Labels: feature request

Me and, seemingly, a few people using this repo have been encountering a problem of the models being loaded into the CPU memory after inactivity/sleep mode/etc. Would there be a possibility to have a flag that would cause the ollama to fail if it cannot load the model onto the GPU and try again?
Repository: go
Issue: x/pkgsite: remove non-canonical spellings of github.com/BurntSushi/toml
Labels: pkgsite,pkgsite/package-removal

### What is the path of the package that you would like to have removed?

github.com/burntsushi/toml, github.com/burntSushi/toml, github.com/Burntsushi/toml

### Are you the owner of this package?

Yes. It's not under my username, but I've been maintaining this for the last 3 or 4 years.

See e.g. commit log, or releases page: https://github.com/BurntSushi/toml/releases

### What is the reason that you could not retract this package instead?

These are outdated casing variants from before Go modules enforced this, and are always "stuck" on an old version. The correct package is https://pkg.go.dev/github.com/BurntSushi/toml.

Someone reported these outdated versions list highly in search engine results (https://github.com/BurntSushi/toml/issues/416), which seems to be correct, at least for some queries in some search engines:

![cap-2024-07-09T20:53:46](https://github.com/golang/go/assets/1032692/10dc4b57-1389-4ebf-97f3-9411e6d18b4a)

Overall, it doesn't strike me as helpful retaining this.
Repository: terminal
Issue: Click-and-drag does not cause search field to lose focus
Labels: Issue-Bug,Area-TerminalControl,Product-Terminal

### Windows Terminal version

1.20.11781.0

### Windows build number

10.0.19045.4529

### Other Software

_No response_

### Steps to reproduce

Settings:
- "Automatically copy selection to clipboard" (`copyOnSelect`): false
- "Automatically focus pane on mouse hover" (`focusFollowMouse`): false


Steps:
1. Echo some arbitrary text on the console
(not needed if for example PowerShell automatically printed its version; or the current working directory)
2. Open the search: <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>F</kbd>
3. Click-and-drag to select any of the output from step 1
ℹ️ Note: Do not perform a separate left click; instead press down the mouse button and directly start dragging your mouse
4. Try for example to copy the selection with <kbd>Ctrl</kbd> + <kbd>C</kbd>

### Expected Behavior

Step 3: The search text field lost focus; the console output got focus
Step 4: You copied your selection to the clipboard

### Actual Behavior

Step 3: A text selection is shown for the console output, _but_ the search text field still has focus
Step 4: You did not copy anything because the search text field still has focus

Side note: If instead of click-and-drag you perform a separate click (press and release) first, then the console output properly has focus.
Repository: PowerToys
Issue: Windows Terminal as Keyboard Manager shortcut does not get focus properly
Labels: Issue-Bug,Needs-Repro,Needs-Triage,Needs-Team-Response

### Microsoft PowerToys version

0.82.0

### Installation method

PowerToys auto-update, WinGet

### Running as admin

No

### Area(s) with issue?

Keyboard Manager

### Steps to reproduce

I've configured <kbd>Ctrl+Alt+T</kbd> to launch `wt.exe` (more specifically, `C:\Users\Tianon\AppData\Local\Microsoft\WindowsApps\wt.exe` explicitly) so that I get a new terminal window.

### ✔️ Expected Behavior

A new terminal window opens, with focus, in my default profile.

### ❌ Actual Behavior

A new terminal window does open, but it doesn't receive the focus (so the icon on the taskbar is blinking, requesting attention), and I have to go find it and switch to it manually (<kbd>Alt+Shift+Tab</kbd> being the fastest way to get to it, since it's created at the bottom of the window stack).

### Other Software

I don't know if it's relevant, but I'm currently on Windows Terminal version 1.20.11781.0.

Additionally, if I do <kbd>Win+R</kbd> and run `wt.exe` from _there_, it gets the focus correctly (which is why I believe this to be something related to how PowerToys is running it, not something Windows Terminal is doing).
Repository: kubernetes
Issue: Horizontal Pod Autoscaler - Ranges
Labels: sig/autoscaling,kind/feature,lifecycle/rotten,needs-triage

**Which component are you using?**:

Horizontal Pod Autoscaler

**Is your feature request designed to solve a problem? If so describe the problem this feature should solve.**:

My feature is meant to allow an easier control of your deployment total capacity

**Describe the solution you'd like.**:

Let's say that im scaling out/in based on CPU. I would like to be able to express that my IF my deployment usage of cpu is:
- inferior to 30%, a scale in operation should take place
- superior to 75%, a scale out operation should take place

any value in between, and the deployment stays put.

I imagine that the yml should look like:

```yml
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment 
    name: sample-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      range: #NOT target, but RANGE!
        type: Utilization
        minUtilization: 30
        maxUtilization: 75
```

**Describe any alternative solutions you've considered.**:

Couldn't come up with alternative solutions

**Additional context.**:

I would be willing to help coding this feature
Repository: deno
Issue: (jupyter) Deno crashes jupyter kernel when pressing stop button in Notebook
Labels: bug,deno jupyter

Version: Deno 1.43.5 (but I can check later this week for other versions)

Reproduction Steps:
1. Create jupyter notebook and open it in Vscode or web interface
2. Select deno kernel
3. Run a cell that sets a variable's value `var server = "foo"`
4. Start long running command as a code block cell (eg a `await sleep(10000)` type fn)
5. Press "Stop" button
6. Deno kernel crashes and loses the internal state of `var server`
<img width="696" alt="image" src="https://github.com/denoland/deno/assets/1026584/cfe2a1ec-cdb0-4832-8193-292f12725fba">

Behavior in python jupyter kernel:
1. Steps 1 through 5 are the same
2. Step 6 will stop the cell without killing the kernel
3. `server` variable's value will still remain available

I'm treating python as the reference behavior here and expecting that deno will generally treat that as the correct behavior.

# Summary

Deno has different and undesirable behavior when executing a jupyter runbook with the deno kernel in that it doesn't tolerate and recover from a "stop" execution command, without a kernel restart.

Severity: mild/moderate usability issue (deno jupyter notebooks are usable but fragile if needing to stop a cell execution. In that case it requries replaying the notebook to that same point in time to rebuild the internal state). I still prefer deno based notebooks to python for the improvements on typing and dependency management, so I'm interested to help make the ecosystem better over time.

I'm not sure where to start debugging this, so I'm starting by reporting it and if I can find out why the behavior happens I'll put up a PR.

Thanks!