sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: vscode
Issue: Linux: Ship RPM packages for EL8/EL9 alongside EL7
Labels: feature-request,install-update,linux,rpm

<!-- ⚠️⚠️ Do Not Delete This! bug_report_template ⚠️⚠️ -->
<!-- Please read our Rules of Conduct: https://opensource.microsoft.com/codeofconduct/ -->
<!-- 🕮 Read our guide about submitting issues: https://github.com/microsoft/vscode/wiki/Submitting-Bugs-and-Suggestions -->
<!-- 🔎 Search existing issues to avoid creating duplicates. -->
<!-- 🧪 Test using the latest Insiders build to see if your issue has already been fixed: https://code.visualstudio.com/insiders/ -->
<!-- 💡 Instead of creating your report here, use 'Report Issue' from the 'Help' menu in VS Code to pre-fill useful information. -->
<!-- 🔧 Launch with `code --disable-extensions` to check. -->
Does this issue occur when all extensions are disabled?: NA

<!-- 🪓 If you answered No above, use 'Help: Start Extension Bisect' from Command Palette to try to identify the cause. -->
<!-- 📣 Issues caused by an extension need to be reported directly to the extension publisher. The 'Help > Report Issue' dialog can assist with this. -->
- VS Code Version: 1.60+
- OS Version: EL8

No `.el8` RPM package has been provided since 1.59.1 (Aug 2021). Only `.el7` RPMs are available for 1.60+.

- See https://packages.microsoft.com/yumrepos/vscode/

Full support by RedHat for RHEL 7 ended in 2019.

- https://access.redhat.com/support/policy/updates/errata

If the same RPM packages are intended for `EL7` and `EL8`, please consider removing `.el7` from the package name.

If there must be separate RPM packages for `EL7` and `EL8`, please consider re-enabling full/official support for `EL8` by providing `.el8` RPMs and storing them in a separately indexed path on the repository mirror so they can be enabled independently from the `EL7` packages for `EL8` installations.
Repository: PowerToys
Issue: Time Zone Convertor by city
Labels: Idea-Enhancement,Product-PowerToys Run,Cost-Large,Run-Plugin

### Description of the new feature / enhancement

Allow us to convert time zones in specific _cities_. 
ex:

20 :35:28 - UTC-07:00 
Phoenix, Arizona (most, United States)

### Scenario when this would be used?

I speak to people all over the country and I deal with appointment times so this would be absolutely amazing for me. I am sure many users planning to use this feature for work could benefit. Not to mention (excuse my ignorance if I am incorrect) it seems like a relatively easy feature to implement! :)

### Supporting information

_No response_
Repository: pytorch
Issue: Tracing model parameter shapes without instantiating the model parameters
Labels: feature,module: nn,triaged

### 🚀 The feature, motivation and pitch

# Request

We would like a way to get a model's parameter shapes without instantiating them. The following is an example call signature.

```python
# MyModel is an `nn.Module`
# instantiate model the usual way
model = MyModel(*args, **kwargs)

# we propose a function on `nn.Module` called `trace_shapes`
# trace shapes without instantiating
shapes = MyModel.trace_shapes(*args, **kwargs)

# `shapes` is a dict with key = param names, value = param shapes
for name, param in model.named_parameters():
  assert(param.shape == shapes[name])
```

# Motivation

Hi,

I'm a maintainer for the [mup package](https://github.com/microsoft/mup). This repo allows one to implement in their models a special parametrization called maximal update parametrization, or muP, that has the special property that narrow and wide networks share the same optimal hyperparameters (like learning rate, initialization, etc). This is demonstrated below on a Transformer trained with adam, where on the left we have the pytorch default parametrization and the right we have muP.
![image](https://user-images.githubusercontent.com/53244851/158045060-81a5f685-6b22-42d5-ac82-437e2bb7f0e1.png)
This property in particular can be used to tune hyperparameters for extremely large neural networks like GPT-3 that is too expensive to train more than once, by just tuning a tiny version of it.

## Current Implementation

To implement muP in a model, we need to annotate the parameter shapes with two pieces of information. For each dimension in a shape, these are

1) is it a width dimension (which will be scaled up or down)?
2) what is the "base value" of this dimension? --- our implementation is designed to replicate the pytorch default when the dimension is equal to its base value, so as to provide backward compatibility.

To obtain 1) and 2), we ask the user to instantiate a "base model" and a "delta model". The delta model is supposed to vary all "width" dimensions compared to the base model. Then, by calling
```python
set_base_shapes(model, base_model, delta=delta_model)
```
the parameters in `model` are annotated by 1) and 2) which are determined by

1) a dimension is a "width" dimension if it varies between `base_model` and `delta_model`, and
2) its base value is given by the value in `base_model`.

## Issues with Current Implementation

The current implementation is not too bad if `base_model` and `delta_model` are relatively small, but when they are big, their instantiations can cost nontrivial time and memory. Worse yet, they might need multiple GPUs to instantiate while `model` can be a small model that fit on a single GPU. Therefore, it'd be much more preferable to just obtain the shapes of `base_model` and `delta_model` without instantiating.

### Alternatives

See `Current Implementation` section above.

### Additional context

_No response_

cc @albanD @mruberry @jbschlosser @walterddr @kshitij12345
Repository: rust
Issue: The Try trait causes str::parse to infer the unit type ()
Labels: T-compiler,A-inference,C-bug

Given the following code:

[Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=8d63b01b21fae5600b5e7bcc1ead3092)

```rust
fn main() {
    || -> anyhow::Result<_> {
        Ok("5".parse::<_>()? / 5.0_f64)
    }().unwrap();
}
```

The current output is:

```
Compiling playground v0.0.1 (/playground)
error[[E0277]](https://doc.rust-lang.org/stable/error-index.html#E0277): cannot divide `()` by `f64`
 [--> src/main.rs:3:30
](https://play.rust-lang.org/#)  |
3 |         Ok("5".parse::<_>()? / 5.0_f64)
  |                              ^ no implementation for `() / f64`
  |
  = help: the trait `Div<f64>` is not implemented for `()`

error[[E0277]](https://doc.rust-lang.org/stable/error-index.html#E0277): the trait bound `(): FromStr` is not satisfied
    [--> src/main.rs:3:16
](https://play.rust-lang.org/#)     |
3    |         Ok("5".parse::<_>()? / 5.0_f64)
     |                ^^^^^ the trait `FromStr` is not implemented for `()`
     |
note: required by a bound in `core::str::<impl str>::parse`

error[[E0283]](https://doc.rust-lang.org/stable/error-index.html#E0283): type annotations needed
 [--> src/main.rs:3:28
](https://play.rust-lang.org/#)  |
3 |         Ok("5".parse::<_>()? / 5.0_f64)
  |                            ^ cannot infer type for type parameter `E`
  |
  = note: multiple `impl`s satisfying `anyhow::Error: From<_>` found in the following crates: `anyhow`, `core`:
          - impl<E> From<E> for anyhow::Error
            where E: 'static, E: std::error::Error, E: Send, E: Sync;
          - impl<T> From<T> for T;
  = note: required because of the requirements on the impl of `FromResidual<Result<Infallible, _>>` for `Result<_, anyhow::Error>`

Some errors have detailed explanations: E0277, E0283.
For more information about an error, try `rustc --explain E0277`.
error: could not compile `playground` due to 3 previous errors
```

Ideally the output should look like:

```
   Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 1.16s
     Running `target/debug/playground`
```

If a type is provided to `str::parse` via the turbofish, rather than leaving it anonymous as `_`, the code compiles well.

```rust
fn main() {
    || -> anyhow::Result<_> {
        Ok("5".parse::<f64>()? / 5.0_f64)
    }().unwrap();
}
```
Repository: godot
Issue: SIGSEGV crash when reopening scene with huge amount of objects
Labels: bug,topic:editor,needs testing,crash

### Godot version

4.0 alpha 4

### System information

Kubuntu 20.04, kernel 5.4.0-100-generic, 64bit, KDE Plasma 5.18.8; AMD FX 6300 16GB RAM, GTX1060 6GB;  Vulkan

### Issue description

When a spatial scene contains a huge amount of objects (about 8K+), the editor crashes with signal 11 when reopen the project.
The critical number of the objects sees may vary from time to time. Also amount of the polygons seems has no effect.
In my practical case the "limit" was reached quite easily: I tested performance for the large world placing a lot of copies of the exported scene, which contains 7 visual meshes (for 3 LOD levels) and one collision mesh. At the best attempt I could place about 8K copies in a simple flat level and the game runs vell at 60fps. But at some less fortunate attempts to add more copies (by duplicating) the editor a) started to load CPU for a very long time without any result; b) started to eat RAM until OS killed it or even entire OS hanged at all. But when even duplication had successfully complete and level saved, the Godot crashes when reopening the project.
The same happened when I grouped about 2-3K copies of exported objects in a separate subscene (which has reopens normally) and then attempted to place copies of it into the main level. Trying this way I noticed two cases: some times the editor succeeded to reopen the level after I removed exceeded copies of the group subscene using a text editor, but some times it failed until I removed all this group subscenes from the level.

### Steps to reproduce

1. Create a spatial scene and add an object into it.
2. Make a very lot of copies that object (e.g. by duplication), total amount of nodes will be about 8K or more (counting a nodes into linked scenes).
3. Save all and close the project.
4. Try to reopen the project - the editor will crash with SIGSEGV.

### Minimal reproduction project

[Godot_crash.txt](https://github.com/godotengine/godot/files/8239383/Godot_crash.txt)
[GodotCrashSIGSEGV.zip](https://github.com/godotengine/godot/files/8239384/GodotCrashSIGSEGV.zip)
Repository: pytorch
Issue: powersgd can not get linear growth due to  extra 2 times allreduce 
Labels: oncall: distributed,triaged,module: ddp,topic: performance

### 🐛 Describe the bug
i use powersgd in low bandwidth situation. and when i add more distributed nodes , the training speed can not linear grow.

1. wthout powersgd,  2nodes total 4cards: speed up ratio is  2.24 (idea 4) , the throughput is 2397 images/s
1. wth powersgd, 2nodes total 4cards: speed up ratio is  3.5 (idea 4) , the throughput is 3735 images/s
2. wth powersgd, 3nodes total 6cards, speed up ratio is 5.23(idea 6),  the throughput is 5501 images/s
3. wth powersgd, 4nodes total 8cards, speed up ratio is 5.46(idea 8), the throughput is 5730 images/s
    obviously, powersgd can boost training performace in low bandwidth situation. but when traning nodes grows, the speed up performance decreases.
    i tried to debug the reason, when i remove the q_memory_dict and p_memory_dict allreduce op at L501 and L522 at https://github.com/pytorch/pytorch/blob/master/torch/distributed/algorithms/ddp_comm_hooks/powerSGD_hook.py     
    4 nodes total 8cards speed up ratio is 6.29(idea 8), the throughput is 6600 images/s

so i think extra 2 times allreduce op harms the  linear speedup growth potentiality.
so is there any solution to eliminate the 2 times allreduce  cost? 

### Versions

https://github.com/pytorch/pytorch/blob/master/torch/distributed/algorithms/ddp_comm_hooks/powerSGD_hook.py#L522
pytorch v1.10 and the ddp algo code is the nearest master branch.
training benchmark is at resnet50 imagenet.
the hardware is V100-32GB, 
the lowest bandwidth between 2 nodes is 3Gbit.
powersgd params:
"matrix_approximation_rank": 4,    # due to accuracy, we choose 4 to balance accuray and speed
"start_powerSGD_iter": 4340,
"min_compression_rate": 2,
"use_error_feedback": true,
"warm_start": true


cc @pietern @mrshenli @pritamdamania87 @zhaojuanmao @satgera @rohan-varma @gqchen @aazzolini @osalpekar @jiayisuse @SciPioneer @H-Huang
Repository: yt-dlp
Issue: Select subtitles of a specific format only
Labels: enhancement

### Checklist

- [X] I'm asking a question and **not** reporting a bug/feature request
- [X] I've looked through the [README](https://github.com/yt-dlp/yt-dlp#readme)
- [X] I've read the [guidelines for opening an issue](https://github.com/yt-dlp/yt-dlp/blob/master/CONTRIBUTING.md#opening-an-issue)
- [X] I've searched the [bugtracker](https://github.com/yt-dlp/yt-dlp/issues?q=) for similar questions including closed ones

### Question

I only want subtitles in a specific format in all languages, if there is no specific format then don't download any subtitles.
```
yt-dlp -s -vU --sub-format "ass/srt" --proxy http://127.0.0.1:7890 --all-subs -- https://www.youtube.com/watch?v=YjtC7kw0SRI
```
But it will download vtt format.

### Verbose log

```shell
[debug] Command-line config: ['-s', '-vU', '--sub-format', 'ass/srt', '--proxy', 'http://127.0.0.1:7890', '--all-subs', '--', 'https://www.youtube.com/watch?v=YjtC7kw0SRI']
[debug] Encodings: locale cp936, fs utf-8, out utf-8, err utf-8, pref cp936
[debug] yt-dlp version 2022.03.13.43044 [29003cf] (win_exe)
[debug] ** This build is unofficial daily builds, provided for ease of use.
[debug] ** Please do not ask for any support.
[debug] Python version 3.8.10 (CPython 64bit) - Windows-10-10.0.19044-SP0
[debug] exe versions: ffmpeg git-2022-02-22-570fda56 (setts), ffprobe 2022-02-21-git-b8e58f0858-essentials_build-www.gyan.dev
[debug] Optional libraries: brotli, Cryptodome, mutagen, sqlite, websockets
[debug] Proxy map: {'http': 'http://127.0.0.1:7890', 'https': 'http://127.0.0.1:7890'}
Latest version: 2022.03.13.43044, Current version: 2022.03.13.43044
yt-dlp is up to date (2022.03.13.43044)
[debug] [youtube] Extracting URL: https://www.youtube.com/watch?v=YjtC7kw0SRI
[youtube] YjtC7kw0SRI: Downloading webpage
[youtube] YjtC7kw0SRI: Downloading android player API JSON
[debug] Sort order given by extractor: quality, res, fps, hdr:12, source, codec:vp9.2, lang, proto
[debug] Formats sorted by: hasvid, ie_pref, quality, res, fps, hdr:12(7), source, vcodec:vp9.2(10), acodec, lang, proto, filesize, fs_approx, tbr, vbr, abr, asr, vext, aext, hasaud, id
[debug] Downloading subtitles: zh-Hans, zh-Hant, en, id
WARNING: No subtitle format found matching "ass/srt" for language zh-Hans, using vtt
WARNING: No subtitle format found matching "ass/srt" for language zh-Hant, using vtt
WARNING: No subtitle format found matching "ass/srt" for language en, using vtt
WARNING: No subtitle format found matching "ass/srt" for language id, using vtt
[debug] Default format spec: bestvideo*+bestaudio/best
[info] YjtC7kw0SRI: Downloading 1 format(s): 248+251
```
Repository: storybook
Issue: noRefCheck functions on the Show Code
Labels: bug,sev:S4

**Describe the bug**
I found something weird when reading the code generated on Storybook, that is every function that I didn't define, shows up as noRefCheck. Even though if I set it manually as undefined.

But no, that's just a background, and I believe that issue might have to do with the `react-element-to-jsx-string`. The actual issue, is that the first function is always written as `() => {}` while the rest functions would be written as `function noRefCheck() {}`. Now that's pretty weird behaviour IMO. Please take a look at this built-in example (?) below

![image](https://user-images.githubusercontent.com/10087890/158068084-268a8a7e-24f0-4aa1-b028-443f4ebec606.png)

Now... isn't that code should be like this below?

```
<Header
  onCreateAccount={() => {}}
  onLogin={() => {}}
  onLogout={() => {}}
  user={{
    name: 'Jane Doe'
  }}
/>
```

it looks more pretty.

**To Reproduce**
I don't think I need to create a repo for this. I just simply:

1. Run `npx create-react-app`
2. Run `npx sb init`
3. Run `npm run storybook`
4. Wait, and open EXAMPLE > Header

**System**
<details>

```
Environment Info:

  System:
    OS: Windows 10 10.0.19042
    CPU: (8) x64 Intel(R) Core(TM) i7-4720HQ CPU @ 2.60GHz
  Binaries:
    Node: 16.6.0 - A:\Program Files\nodejs\node.EXE
    Yarn: 1.22.17 - ~\AppData\Roaming\npm\yarn.CMD
    npm: 7.24.1 - A:\Program Files\nodejs\npm.CMD
  Browsers:
    Chrome: 99.0.4844.51
    Edge: Spartan (44.19041.1266.0), Chromium (99.0.1150.39)
  npmPackages:
    @storybook/addon-actions: ^6.4.19 => 6.4.19
    @storybook/addon-essentials: ^6.4.19 => 6.4.19
    @storybook/addon-interactions: ^6.4.19 => 6.4.19
    @storybook/addon-links: ^6.4.19 => 6.4.19
    @storybook/builder-webpack5: ^6.4.19 => 6.4.19
    @storybook/manager-webpack5: ^6.4.19 => 6.4.19
    @storybook/node-logger: ^6.4.19 => 6.4.19
    @storybook/preset-create-react-app: ^4.0.1 => 4.0.1
    @storybook/react: ^6.4.19 => 6.4.19
    @storybook/testing-library: ^0.0.9 => 0.0.9
```

</details>

**Additional context**
I think I found [the culprit](https://github.com/storybookjs/storybook/blob/8d7fa4249cc73f315cfc15ebd8c6f0d574f341d5/addons/docs/src/frameworks/react/jsxDecorator.tsx#L137), just replace the `replace` with `replaceAll`. If you allow, I can create a PR to fix this including adding a new unit test to cover this one. wdyt?
Repository: rust
Issue: Erroneous unused_unsafe diagnostic for macro invocations
Labels: A-diagnostics,T-compiler

<!--
Thank you for filing a bug report! 🐛 Please provide a short summary of the bug,
along with any information you feel relevant to replicating the bug.

If you cannot produce a minimal reproduction case (something that would work in
isolation), please provide the steps or even link to a repository that causes
the problematic output to occur.
-->

Given the following code: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=4fc81da81334f7865f292f98a62735a3

```rust
unsafe fn unsafe_code() { }

macro_rules! macro_inner
{
    () => { unsafe { unsafe_code(); }  };
}
macro_rules! macro_outer
{
    () => { unsafe { macro_inner!(); unsafe_code(); } };
}

fn main()
{
    macro_inner!();

    macro_outer!();
}
```

The current output is:

```
warning: unnecessary `unsafe` block
  --> src\poc.rs:5:13
   |
5  |     () => { unsafe { unsafe_code(); }  };
   |             ^^^^^^ unnecessary `unsafe` block
...
9  |     () => { unsafe { macro_inner!(); unsafe_code(); } };
   |             ------ because it's nested under this `unsafe` block
...
16 |     macro_outer!();
   |     -------------- in this macro invocation
   |
   = note: this warning originates in the macro `macro_inner` (in Nightly builds, run with -Z macro-backtrace for more info)
```

This is obviously wrong, because `macro_inner!` is *also* invoked at line 14, in the `main` function, outside an `unsafe` block. The analyzer seems to only take in account the invocation occurring inside the `macro_outer!` expansion during the `unused_unsafe` check.

Although it makes technical sense to perform the analysis that way, the result is that an incorrect piece of advice is given to the user ("This `unsafe` specifier is unnecessary, remove it"). Here, removing the `unsafe` block breaks the code, for the first invocation.

Tested on stable 1.58.1 and nightly 1.61.0 (2022-02-23).

**EDIT:** still present on 1.67.0 (2022-11-02).

PS: Sorry if this is not in the right triage category, I wasn't sure whether it would better fit the "Diagnostics" or the "Bug" label.
Repository: rust
Issue: Apparently unnecessary bound check
Labels: A-LLVM,I-slow,T-compiler

Please see [https://godbolt.org/z/39xWbfzsd](https://godbolt.org/z/39xWbfzsd)

line 26  (`.LBB1_32`), there is an unnecessary bound check, but a strange thing is if you change the line 15 `if i >= len {` to `if i > len {`, this bound check can be optimized.
`i >= len` should contain the case of `i > len`.

and I'm not sure why `.LBB1_29` exists? It doesn't seem to have any effect.
Repository: flutter
Issue: Support for Tenant in google_sign_in package
Labels: c: new feature,p: google_sign_in,package,c: proposal,team-ecosystem,P3,triaged-ecosystem

I want to use the https://pub.dev/packages/google_sign_in package but there is no option to specify a tenant.

The Identity Platform [example](https://cloud.google.com/identity-platform/docs/multi-tenancy-authentication) uses firebase.auth, however I do not want to use firebase_auth package, I want to use the google_sign_in package.

It seems odd that I need to have a dependency for firebase if I am not using it.
Repository: pytorch
Issue: All-caps names for pages are confusing
Labels: triaged,module: doc infra

### 📚 The doc issue

Whilst these titles look nice, it's not obvious without closer inspection what this page actually is for.

![22-03-13-201743](https://user-images.githubusercontent.com/5500712/158077668-85b865b3-f699-47d4-8279-09d2a1c6468d.png)
![22-03-13-201747](https://user-images.githubusercontent.com/5500712/158077675-2077cab5-847b-482d-a376-9bcb8f91c5b1.png)



### Suggest a potential alternative/fix

Don't full-caps the titles of pages, allow them to match the actual case of what they are documenting.

cc @ezyang @zou3519 @brianjo
Repository: rust
Issue: Tracking Issue for extra UTF-16 methods
Labels: T-libs-api,C-tracking-issue

<!--
Thank you for creating a tracking issue!

Tracking issues are for tracking a feature from implementation to stabilization.

Make sure to include the relevant RFC for the feature if it has one.

If the new feature is small, it may be fine to skip the RFC process. In that
case, you can use use `issue = "none"` in your initial implementation PR. The
reviewer will ask you to open a tracking issue if they agree your feature can be
added without an RFC.
-->

Feature gate: `#![feature(utf16_extra)]`

This is a tracking issue for extra UTF-16 methods, which currently just includes `u16::is_utf16_surrogate`.

<!--
Include a short description of the feature.
-->

### Public API

<!--
For most library features, it'd be useful to include a summarized version of the public API.
(E.g. just the public function signatures without their doc comments or implementation.)
-->

```rust
impl u16 {
    pub const fn is_utf16_surrogate(self) -> bool;
}
```

### Steps / History

<!--
For larger features, more steps might be involved.
If the feature is changed later, please add those PRs here as well.
-->

- [x] Implementation of `u16::is_utf16_surrogate` (#94713)
- [ ] Final comment period (FCP)
- [ ] Stabilization PR

<!--
Once the feature has gone through a few release cycles and there are no
unresolved questions left, the feature might be ready for stabilization.

If this feature didn't go through the RFC process, a final comment period
(FCP) is always needed before stabilization. This works as follows:

A library API team member can kick off the stabilization process, at which point
the rfcbot will ask all the team members to verify they agree with
stabilization. Once enough members agree and there are no concerns, the final
comment period begins: this issue will be marked as such and will be listed
in the next This Week in Rust newsletter. If no blocking concerns are raised in
that period of 10 days, a stabilzation PR can be opened by anyone.
-->

### Unresolved Questions

<!--
Include any open questions that need to be answered before the feature can be
stabilised. If multiple (unrelated) big questions come up, it can be a good idea
to open a separate issue for each, to make it easier to keep track of the
discussions.

It's useful to link any relevant discussions and conclusions (whether on GitHub,
Zulip, or the internals forum) here.
-->

- What other useful UTF-16 methods should be exposed?