sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: kubernetes
Issue: Find a better place to initialize volume manager informers
Labels: sig/storage,kind/feature,lifecycle/frozen,needs-triage

<!-- Please only use this template for submitting enhancement requests -->

**What would you like to be added**:
Background: https://github.com/kubernetes/kubernetes/pull/93130#discussion_r516888787

Right now `WaitForCacheSync` for csi informers is called right before we need to read from it, which is well after any initialization, and gets called repeatedly. 

However, there isn't a great place to move it right now. Places that have been tried:
- After we start the informer in `volumePluginMgr.Run`. Problem here is that that the volume reconciler has already started before this, which means csi could already be processing requests.
- We tried moving `volumePluginMgr.Run` before starting the volume reconciler. But the volume reconciler is needed to bootstrap kubelet before there's a connection to apiserver.
- `csiPlugin.Init`. This appears to have similar bootstrap ordering issues.

Maybe we need some sort of `plugin.Start` interface?
Repository: flutter
Issue: Move verification script in flutter_tools/test/general.shard/android/gradle_test.dart to integration.shard
Labels: team,tool,P3,team-tool,triaged-tool
Repository: godot
Issue: Godot 3.2.3 move_and_slide_with_snap() doesn't function correctly at 144fps. 
Labels: topic:physics

**Godot version:**
<!-- Specify commit hash if using non-official build. -->
v3.2.3


**OS/device including version:**
<!-- Specify GPU model, drivers, and the backend (GLES2, GLES3, Vulkan) if graphics-related. -->
GTX 980ti,  Windows 10 64 bit


**Issue description:**
<!-- What happened, and what was expected. -->

Godot 3.2.3 `move_and_slide_with_snap() `doesn't function as intended with moving platforms at 144hz/fps. The player will slowly slide off moving platforms when at 144fps. The function works as intended at 60fps. 



**Steps to reproduce:**
Stand on the blue moving platform in the included project with a 144fps hz display. 


**Minimal reproduction project:**
<!-- A small Godot project which reproduces the issue. Drag and drop a zip archive to upload it. -->
Stand on the platform in this project with a 144fps display. 
[First Person Starter.zip](https://github.com/godotengine/godot/files/5503727/First.Person.Starter.zip)
Repository: create-react-app
Issue: Add `--watchAll=false` to coverage docs
Labels: issue: proposal,needs triage

### Is your proposal related to a problem?

Yes, when I follow the instructions on https://create-react-app.dev/docs/running-tests/#coverage-reporting to run coverage reporting, I get an empty report. Others have reported this in #6888 #7838 #9322 #9876.

### Describe the solution you'd like

Until this changes, I propose updating https://github.com/facebook/create-react-app/blame/master/docusaurus/docs/running-tests.md#L179 to prescribe `npm test -- --coverage --watchAll=false`

### Describe alternatives you've considered

Ideally this behavior would be changed by the Jest team, but https://github.com/facebook/jest/issues/7331 doesn't seem to have much activity. Maybe there's another issue that's tracking it.
Repository: vscode
Issue: Column-view (Miller columns) for the breadcrumbs 
Labels: feature-request,breadcrumbs

<!-- ⚠️⚠️ Do Not Delete This! feature_request_template ⚠️⚠️ -->
<!-- Please read our Rules of Conduct: https://opensource.microsoft.com/codeofconduct/ -->
<!-- Please search existing issues to avoid creating duplicates. -->
<!-- Describe the feature you'd like. -->

I would like to have the other alternatives for each breadcrumb to stay visible (similar to outline view), but be arranged in vertical columns ([Miller columns](https://en.wikipedia.org/wiki/Miller_columns) aka [cascading lists](http://designinginterfaces.com/firstedition/index.php?page=Cascading_Lists)) to get the features of the Java Browsing perspective i.e. Smalltalk code-browers in VSCode:

<img width="1487" alt="example" src="https://user-images.githubusercontent.com/1824527/98421361-79bd7580-2089-11eb-841c-aece5904a043.png">

In the mockup, I used the breadcrumbs as source, but I'd even more would like to just have the contents of the outline-view be displayed like this.

Is there a way to achieve this? For example via writing an extension?
Repository: pytorch
Issue: per channel observer to work for weights of groupwise conv transpose
Labels: oncall: quantization,low priority,triaged

Currently per channel observer only works with weights of group size 1, but ideally it should work with group > 1 as well.

the layout of the weight of groupwise convolution before and after quantization should be:
OC/G IC HW (float) --> G (OC/G)(IC/G) HW (int)
with quantization parameters for each output channel.

1. Add group support in per channel observer
2. Add group support in quantize_per_channel
3. Modify the quantized convtranspose op to work with the new quantized weight

cc @jianyuh @raghuramank100 @jamesr66a @vkuzo @jgong5 @Xia-Weiwen @leslie-fang-intel @jerryzh168 @dzhulgakov
Repository: PowerToys
Issue: Define a Foreground Zone which always contains the Foregrounded Window
Labels: Idea-Enhancement,FancyZones-Layouts,Product-FancyZones

I want to define a specific Fancy Zone as the Foreground Zone (for my multi-monitor setup this would be a zone spanning my entire primary monitor). The Foreground Zone contains only a single window. Whenever a new window is foregrounded while Foreground Zone is enabled, it snaps to the Foreground Zone. When a new foreground window is set, the previous foreground window returns to whichever Fancy Zone it was in prior to being foregrounded; if it wasn't previously in a Fancy Zone it moves to some Fancy Zone according to a default or user defined rule.

The benefit of this use case is that it allows the user to focus on a specific area of the screen and always bring the foreground window to their focus. This reduces eye and neck strain.

If you'd like to see this feature implemented, add a 👍 reaction to this post.
Repository: rust
Issue: Linking a static C library does not include all symbols
Labels: A-linkage,P-low,T-lang

This relates to #15460. On 1.47 stable and 1.48 nightly, when using cc/cbindgen, if a symbol in the C file is not used by the .rs file, then it is not in the resulting cdylib. It is possible to force the symbol to be included by "calling" it as show in https://github.com/rust-lang/rust/issues/19321 .

The linked repository is able to reproduce this. Testing on OpenSUSE tumbleweed (fully patched with gcc10). After `cargo build` then the resulting libdemo.so does not contain the symbol `wrapper_add`. 

This appears to be a regression since #15460 which was intended to resolve this behaviour. I appreciate your advice on this, thanks,

https://github.com/Firstyear/demo_r_link

EDIT: Worth noting in wrapper.c that it does not need to link to any R libs, and that SEXP is a typdef to `typedef struct SEXPREC *SEXP;`
Repository: flutter
Issue: Suggestion: Ability to check if asset exists without loading
Labels: framework,f: material design,a: images,c: proposal,P3,team-design,triaged-design

<!-- Thank you for using Flutter!

     If you are looking for support, please check out our documentation
     or consider asking a question on Stack Overflow:
      * https://flutter.dev/
      * https://api.flutter.dev/
      * https://stackoverflow.com/questions/tagged/flutter?sort=frequent

     If you have found a bug or if our documentation doesn't have an answer
     to what you're looking for, then fill out the template below. Please read
     our guide to filing a bug first: https://flutter.dev/docs/resources/bug-reports
-->

## Use case

<!--
     Please tell us the problem you are running into that led to you wanting
     a new feature.

     Is your feature request related to a problem? Please give a clear and
     concise description of what the problem is.

     Describe the alternative solutions you've considered. Is there a package
     on pub.dev/flutter that already solves this?
-->

I'm currently using this:
```dart
try {
      final bundle = DefaultAssetBundle.of(context);
      await bundle.load(imagePath);
      return AssetImage(imagePath);
} catch (e) {)
return null;
```

The specific use case is that I'd like a to use an included image asset if available with a fallback if not (i.e. if the above returns null) without actually having to load the image into memory before returning the `AssetImage`.

## Proposal

<!--
     Briefly but precisely describe what you would like Flutter to be able to do.

     Consider attaching images showing what you are imagining.

     Does this have to be provided by Flutter directly, or can it be provided
     by a package on pub.dev/flutter? If so, maybe consider implementing and
     publishing such a package rather than filing a bug.
-->

Since `load()` actually loads the image data, it seems like it would be more efficient if there were simply an `exists()` function like most file-based I/O operations have (including Firebase).
Repository: pytorch
Issue: Whats Pytorch's policy on adding support for a wider range of hardwares for training and inference? 
Labels: triaged,module: backend

I was going to ask for DML support for Pytorch, but I noticed there are other frameworks which Pytorch seemingly completely ignored/s and as time goes by the options available to technologies built on top of Pytorch shrink more and more.  
Pytorch has been stagnant in this area for a long time, and the best option that has always been offered was to go and use onnx. 
While onnx is a good idea, its still far from being complete and the support really requires dedicated attention/suppot from Pytorch. Pytorch is never a first class citizen when it comes to bug fixes, new features, etc in these cases.

While Pytorch seems to be reluctant to step into this area, others such as Tensorflow have invested heavily and provide a wide range of options for many usecases. Nearly all of such frameworks/libraries have a dedicated tensorflow version, which allows a great flexibility/seamless integration for the technologies that use tensorflow as their backend and this is a very bad shortcomming for Pytorch.  
 
Looking at the recent attempts doesnt convey an optimistic future:     
The support for tvm was dropped, The support for Intel's DNNL/OneAPI has been stagnant so far specially for the support for gpus, the support for dml was ignored and never looked back!  
So whats the policy on this? Is there any plan to do something in this regard and close this ever growing gap between Pytorch and the likes such as Tensorflow, etc) or its still the same policy of not supporting such frameworks. 
if there is no plan on supporting such, is there a plan for the alternative that is actually actively supported in  a dedicated manner by Pytorch and can be reliably trusted and used ?
Repository: go
Issue: strconv: ParseFloat seems not working correctly with a large exponent
Labels: NeedsInvestigation

### What version of Go are you using (`go version`)?

<pre>
$ go version
go version go1.15.4 linux/amd64
</pre>

### Does this issue reproduce with the latest release?
Yes

### What operating system and processor architecture are you using (`go env`)?

<details><summary><code>go env</code> Output</summary><br><pre>
$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/hiroshi/.cache/go-build"
GOENV="/home/hiroshi/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/home/hiroshi/go/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/home/hiroshi/go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/home/hiroshi/Downloads/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/home/hiroshi/Downloads/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build943543493=/tmp/go-build -gno-record-gcc-switches"
</pre></details>

### What did you do?
Run the below program (Go Playground: https://play.golang.org/p/BKUGd_uDl9_Q)

```golang
fmt.Println(strconv.ParseFloat("0."+strings.Repeat("0", 100000)+"9e100000", 64)) // 0 <nil>
fmt.Println(strconv.ParseFloat("9"+strings.Repeat("0", 100000)+"e-100000", 64))  // 0 <nil>
```

### What did you expect to see?
I assume the first line should print `0.9 <nil>` and the second should print `9 <nil>`.

### What did you see instead?
I see the below output.

```
0 <nil>
0 <nil>
```
Repository: tensorflow
Issue: BUG: Keras SaveModel does not properly save optimizer state
Labels: type:bug,comp:keras,TF 2.3

EDIT: looks like this is a dupe of #42749, I'll leave this up for now in case since that issue does not have as reproducible high level example, but feel free to close.

This happens at least for Adam (does not apply to SGD for example, did not test with others).

Tested on `tf-nightly` and `tf==2.3.0`.

TL;DR: running a `tf.kerasModel` through `tf.keras.models.load(model.save)` does not properly preserve the state of optimizers for certain optimizers (see #42749 for more details).

The [docs](https://www.tensorflow.org/api_docs/python/tf/keras/Model#the_savefile_includes_2) read:

> The savefile includes:
> * The model architecture, allowing to re-instantiate the model.
> * The model weights.
> * The state of the optimizer, allowing to resume training exactly where you left off.

Full example:

```python3
import numpy as np
import tensorflow as tf
from tensorflow import keras


# Define a minimal model
inp = keras.layers.Input((1, ))
out = keras.layers.Dense(1)(inp)
m1 = keras.Model(inp, out)
m1.compile(loss="mae", optimizer="adam")

# Create some test data
X, y = np.random.random((100, )), np.random.random((100, ))

# Fit the model to the test data to get everything initialized
m1.fit(X, y, verbose=0)


def roundtrip(model: keras.Model) -> keras.Model:
    save_dir = "/tmp/mymodel"
    model.save(save_dir)
    restored = keras.models.load_model(save_dir)
    return restored


# Create a copy of the fitted m1
m2 = roundtrip(m1)

# Weights are preserved correctly, this passes
np.testing.assert_allclose(m1.predict(X), m2.predict(X))

# New lets train once more round
m1.fit(X, y, verbose=0)
# Since optimizer weights/state is not preserved, this fit call
# results in different weights in m2, which makes the predictions differ
m2.fit(X, y, verbose=0)
try:
    np.testing.assert_allclose(m1.predict(X), m2.predict(X), rtol=0.1)  # large relative tolerance
except AssertionError:
    print("AssertionError: model predictions differ")

# Diagnosis: optimizer weights are not preserved
weights1 = m1.optimizer.get_weights()
m3 = roundtrip(m1)
weights3 = m3.optimizer.get_weights()

try:
    assert weights1 == weights3
except AssertionError:
    print("AssertionError: optimizer weights differ")
    print(f"    {weights1}\n    vs\n    {weights3}")

# Further, we can't even restore the weights without training!
try:
    m3.optimizer.set_weights(weights1)
except Exception as e:
    print(str(e).split(" Provided weights:")[0])
```
Repository: pytorch
Issue: Ninja-built CUDAExtension build process ignores changed #include dependencies
Labels: module: build,triaged

## 🐛 Bug

I discovered that if a file specified in a CUDAExtension sources directive (a compilable file that goes into the extension) have #include directives, and the pointed to files change, the next build does not recompile the dependencies. This is of course necessary. I'm wondering if something is missing in the emitted ninja.build or if the generated .d dependency files are wiped (I couldn't find them in the temp build directories anywhere after a build, only the ninja.build file itself).

Or if there is a need to explicitly state include-dependencies in the CUDAExtension instance, files that are not to be compiled but that are sources of dependencies.

## To Reproduce

I just use the minimal setuptools + CUDAExtension examples from the canonical tutorial.

```
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension

if __name__ == '__main__':
    setup(name='xyz',
          version='1.0.0',
          ext_modules=[
              CUDAExtension(name='xyz_convolutions', sources=['xyz_convolutions.cpp', 'xyz_convolutions.cu',]),
          ],
          cmdclass={'build_ext': BuildExtension})

```

The .cpp file is the pybind wrapper and the .cu file is the kernel invocation, and the xyz_convolutions.cu file has a single #include "xyz_kernel.cu" file which includes the actual kernel code.

I think it's irrelevant that I include the kernel code like this, it could as well have been a file that does some #defines or something.

## Expected behavior

If I run the script again after changing an include dependency like the xyz_kernel.cu file in the example above, the expected behaviour is that the dependent .cu files (xyz_convolutions.cu in the example) are recompiled which they are not.

## Environment

 - PyTorch Version (e.g., 1.0): 1.7.0
 - OS (e.g., Linux): Linux Ubuntu 18.04LTS
 - How you installed PyTorch (`conda`, `pip`, source): pip
 - Python version: 3.6
 - CUDA/cuDNN version: 11.1
 - GPU models and configuration: RTX 3080


cc @malfet @seemethere @walterddr
Repository: godot
Issue: AudioStreamPlayer not emitting signal when AudioStreamGeneratorPlayback audio frames are consumed.
Labels: bug,confirmed,topic:audio

<!-- Please search existing issues for potential duplicates before filing yours:
https://github.com/godotengine/godot/issues?q=is%3Aissue
-->

**Godot version:**
3.2 branch at commit be625f67ee4c233a6f8836a3b9af5ab14b1b0fcf


**OS/device including version:**
<!-- Specify GPU model, drivers, and the backend (GLES2, GLES3, Vulkan) if graphics-related. -->
Arch Linux

**Issue description:**
<!-- What happened, and what was expected. -->
As I was figuring out how the audio generator demo worked, I noticed that partially or completely filling the `AudioStreamGeneratorPlayback` audio frames once and the playing them would not make the `AudioStreamPlayer` fire any signals.

I was expecting a "finished" signal to fire, or perhaps a "loading" or "waiting" signal with which one could use to just stop the `AudioStreamPlayer` completely if wanted.

**Steps to reproduce:**
Run the attached project. The output and code from `generator_demo.gd` makes this issue more easily visible.

As a workaround, to stop the `AudioStreamPlayer` when using an `AudioStreamGenerator` resource, users have to keep track of the available audio frames in the `AudioStreamGeneratorPlayback`. Once all the available frames are consumed, the maximum available frames is visible again which means that the `AudioStreamGeneratorPlayback` is empty, which can be used to stop the `AudioStreamPlayer`. This is shown in the `generator_demo.gd` within the attached project.

**Minimal reproduction project:**
[generator.zip](https://github.com/godotengine/godot/files/5504787/generator.zip)
Based on: https://github.com/godotengine/godot-demo-projects/tree/master/audio/generator

**Related**
#30737
#33579
#33602
Repository: tensorflow
Issue: Bad performance of tf.data.Dataset API when dealing with windowed inputs / timeseries problems / 3D arrays
Labels: stat:awaiting tensorflower,comp:data,type:performance,TF 2.4

<em>Please make sure that this is an issue related to performance of TensorFlow.
As per our
[GitHub Policy](https://github.com/tensorflow/tensorflow/blob/master/ISSUES.md),
we only address code/doc bugs, performance issues, feature requests and
build/installation issues on GitHub. tag:performance_template</em>

**System information**
Have I written custom code (as opposed to using a stock example script provided in TensorFlow): Yes
TensorFlow installed from (source or binary): binary
TensorFlow version (use command below): 2.4.0-dev20201006
Python version: 3.7

**Describe the current behavior**
I work on timeserie forecasting, involving manipulating 3-D arrays as inputs of my models (batch_size, nb_timesteps, nb_features).
I used to rely on Keras "Sequence" objects to feed the "fit" function.
Yet, I recently chose to move on tf.data.Dataset API to have a more robust input pipeline. In addition, this allow using named features, which is a huge advantage. Nonetheless, I found that usage and performances of tf datasets could be improved when it comes to window data:

1.  windowing a dataset of named features is slow and not very intuitive. I thought this could maybe be improved (see issue https://github.com/tensorflow/tensorflow/issues/43703)

2. datasets of windows tend to be heavy. While shuffling, the dataset "shuffle" method necessarily pre-buffers all samples to use for training, resulting in huge memory usage, which makes training of such models not tractable with the Dataset API. Note that for timeseries problems, as we start from chronologically-ordered data, it is very important to get a "perfect" shuffling, hence we cannot reduce the shuffle buffer size (it is necessary to set it equal or greater than the dataset cardinality). I was thinking: maybe the "Shuffle" method could be improved so that it does not pre-buffer all possible samples, but rather does the following:
           - index the whole dataset, in case cardinality can be known
           - shuffle the index list
           - pick-up a new batch based on the shuffled index list, at each training step
This would be very similar to the way the Keras Sequence works. However, I think the Keras Sequence lack a lot of other interesting features brought by the Dataset API. So it would be good if we could get the best of the two in the Dataset API, which now seems to be the standard for data input pipelines in tf.

**Describe the expected behavior**
improved performance and architecture for windowed datasets, using tf.data.Dataset API