([简体中文](./README_cn.md)|English)

     Quick Start
  |  Documents
  |  Models List
  |  AIStudio Courses
  |  NAACL2022 Best Demo Award Paper
  |  Gitee

------------------------------------------------------------------------------------

**PaddleSpeech** is an open-source toolkit on [PaddlePaddle](https://github.com/PaddlePaddle/Paddle) platform for a variety of critical tasks in speech and audio, with the state-of-art and influential models.

**PaddleSpeech** won the [NAACL2022 Best Demo Award](https://2022.naacl.org/blog/best-demo-award/), please check out our paper on [Arxiv](https://arxiv.org/abs/2205.12007).

##### Speech Recognition

       Input Audio
       Recognition Result

      I knocked at the door on the ancient side of the building.

      我认为跑步最重要的就是给我带来了身体健康。

##### Speech Translation (English to Chinese)

       Input Audio
       Translations Result

      我 在 这栋 建筑 的 古老 门上 敲门。

##### Text-to-Speech

       Input Text
      Synthetic Audio

      Life was like a box of chocolates, you never know what you're gonna get.

      早上好，今天是2020/10/29，最低温度是-3°C。

      季姬寂，集鸡，鸡即棘鸡。棘鸡饥叽，季姬及箕稷济鸡。鸡既济，跻姬笈，季姬忌，急咭鸡，鸡急，继圾几，季姬急，即籍箕击鸡，箕疾击几伎，伎即齑，鸡叽集几基，季姬急极屐击鸡，鸡既殛，季姬激，即记《季姬击鸡记》。

      大家好，我是 parrot 虚拟老师，我们来读一首诗，我与春风皆过客，I and the spring breeze are passing by，你携秋水揽星河，you take the autumn water to take the galaxy。

      宜家唔系事必要你讲，但系你所讲嘅说话将会变成呈堂证供。

      各个国家有各个国家嘅国歌

For more synthesized audios, please refer to [PaddleSpeech Text-to-Speech samples](https://paddlespeech.readthedocs.io/en/latest/tts/demo.html).

##### Punctuation Restoration

       Input Text
       Output Text

      今天的天气真不错啊你下午有空吗我想约你一起去吃饭
      今天的天气真不错啊！你下午有空吗？我想约你一起去吃饭。

### Features

Via the easy-to-use, efficient, flexible and scalable implementation, our vision is to empower both industrial application and academic research, including training, inference & testing modules, and deployment process. To be more specific, this toolkit features at:
- 📦  **Ease of Use**: low barriers to install, [CLI](#quick-start), [Server](#quick-start-server), and [Streaming Server](#quick-start-streaming-server) is available to quick-start your journey.
- 🏆  **Align to the State-of-the-Art**: we provide high-speed and ultra-lightweight models, and also cutting-edge technology.
- 🏆  **Streaming ASR and TTS System**: we provide production ready streaming asr and streaming tts system.
- 💯  **Rule-based Chinese frontend**: our frontend contains Text Normalization and Grapheme-to-Phoneme (G2P, including Polyphone and Tone Sandhi). Moreover, we use self-defined linguistic rules to adapt Chinese context.
- 📦  **Varieties of Functions that Vitalize both Industrial and Academia**:
  - 🛎  *Implementation of critical audio tasks*: this toolkit contains audio functions like  Automatic Speech Recognition, Text-to-Speech Synthesis, Speaker Verfication, KeyWord Spotting, Audio Classification, and Speech Translation, etc.
  - 🔬  *Integration of mainstream models and datasets*: the toolkit implements modules that participate in the whole pipeline of the speech tasks, and uses mainstream datasets like LibriSpeech, LJSpeech, AIShell, CSMSC, etc. See also [model list](#model-list) for more details.
  - 🧩  *Cascaded models application*: as an extension of the typical traditional audio tasks, we combine the workflows of the aforementioned tasks with other fields like Natural language processing (NLP) and Computer Vision (CV).

### Recent Update
- 👑 2023.05.31: Add [WavLM ASR-en](https://github.com/PaddlePaddle/PaddleSpeech/blob/develop/examples/librispeech/asr5), WavLM fine-tuning for ASR on LibriSpeech.
- 👑 2023.05.04: Add [HuBERT ASR-en](https://github.com/PaddlePaddle/PaddleSpeech/blob/develop/examples/librispeech/asr4), HuBERT fine-tuning for ASR on LibriSpeech.
- ⚡ 2023.04.28: Fix [0-d tensor](https://github.com/PaddlePaddle/PaddleSpeech/pull/3214), with the upgrade of paddlepaddle==2.5, the problem of modifying 0-d tensor has been solved.
- 👑 2023.04.25: Add [AMP for U2 conformer](https://github.com/PaddlePaddle/PaddleSpeech/pull/3167).
- 🔥 2023.04.06: Add [subtitle file (.srt format) generation example](./demos/streaming_asr_server).
- 🔥 2023.03.14: Add SVS(Singing Voice Synthesis) examples with Opencpop dataset, including [DiffSinger](./examples/opencpop/svs1)、[PWGAN](./examples/opencpop/voc1) and [HiFiGAN](./examples/opencpop/voc5), the effect is continuously optimized.
- 👑 2023.03.09: Add [Wav2vec2ASR-zh](./examples/aishell/asr3).
- 🎉 2023.03.07: Add [TTS ARM Linux C++ Demo (with C++ Chinese Text Frontend)](./demos/TTSArmLinux).
- 🔥 2023.03.03 Add Voice Conversion [StarGANv2-VC synthesize pipeline](./examples/vctk/vc3).
- 🎉 2023.02.16: Add [Cantonese TTS](./examples/canton/tts3).
- 🔥 2023.01.10: Add [code-switch asr CLI and Demos](./demos/speech_recognition).
- 👑 2023.01.06: Add [code-switch asr tal_cs recipe](./examples/tal_cs/asr1/).
- 🎉 2022.12.02: Add [end-to-end Prosody Prediction pipeline](./examples/csmsc/tts3_rhy) (including using prosody labels in Acoustic Model).
- 🎉 2022.11.30: Add [TTS Android Demo](./demos/TTSAndroid).
- 🤗 2022.11.28: PP-TTS and PP-ASR demos are available in [AIStudio](https://aistudio.baidu.com/aistudio/modelsoverview) and [official website
 of paddlepaddle](https://www.paddlepaddle.org.cn/models).
- 👑 2022.11.18: Add [Whisper CLI and Demos](https://github.com/PaddlePaddle/PaddleSpeech/pull/2640), support multi language recognition and translation.
- 🔥 2022.11.18: Add [Wav2vec2 CLI and Demos](./demos/speech_ssl), Support ASR and Feature Extraction.
- 🎉 2022.11.17: Add [male voice for TTS](https://github.com/PaddlePaddle/PaddleSpeech/pull/2660).
- 🔥 2022.11.07: Add [U2/U2++ C++ High Performance Streaming ASR Deployment](https://github.com/PaddlePaddle/PaddleSpeech/blob/develop/runtime/examples/u2pp_ol/wenetspeech).
- 👑 2022.11.01: Add [Adversarial Loss](https://arxiv.org/pdf/1907.04448.pdf) for [Chinese English mixed TTS](./examples/zh_en_tts/tts3).
- 🔥 2022.10.26: Add [Prosody Prediction](./examples/other/rhy) for TTS.
- 🎉 2022.10.21: Add [SSML](https://github.com/PaddlePaddle/PaddleSpeech/discussions/2538) for TTS Chinese Text Frontend.
- 👑 2022.10.11: Add [Wav2vec2ASR-en](./examples/librispeech/asr3), wav2vec2.0 fine-tuning for ASR on LibriSpeech.
- 🔥 2022.09.26: Add Voice Cloning, TTS finetune, and [ERNIE-SAT](https://arxiv.org/abs/2211.03545) in [PaddleSpeech Web Demo](./demos/speech_web).
- ⚡ 2022.09.09: Add AISHELL-3 Voice Cloning [example](./examples/aishell3/vc2) with ECAPA-TDNN speaker encoder.
- ⚡ 2022.08.25: Release TTS [finetune](./examples/other/tts_finetune/tts3) example.
- 🔥 2022.08.22: Add [ERNIE-SAT](https://arxiv.org/abs/2211.03545) models: [ERNIE-SAT-vctk](./examples/vctk/ernie_sat)、[ERNIE-SAT-aishell3](./examples/aishell3/ernie_sat)、[ERNIE-SAT-zh_en](./examples/aishell3_vctk/ernie_sat).
- 🔥 2022.08.15: Add [g2pW](https://github.com/GitYCC/g2pW) into TTS Chinese Text Frontend.
- 🔥 2022.08.09: Release [Chinese English mixed TTS](./examples/zh_en_tts/tts3).
- ⚡ 2022.08.03: Add ONNXRuntime infer for  TTS CLI.
- 🎉 2022.07.18: Release VITS: [VITS-csmsc](./examples/csmsc/vits)、[VITS-aishell3](./examples/aishell3/vits)、[VITS-VC](./examples/aishell3/vits-vc).
- 🎉 2022.06.22: All TTS models support ONNX format.
- 🍀 2022.06.17: Add [PaddleSpeech Web Demo](./demos/speech_web).
- 👑 2022.05.13: Release [PP-ASR](./docs/source/asr/PPASR.md)、[PP-TTS](./docs/source/tts/PPTTS.md)、[PP-VPR](docs/source/vpr/PPVPR.md).
- 👏🏻 2022.05.06: `PaddleSpeech Streaming Server` is available for `Streaming ASR` with `Punctuation Restoration` and `Token Timestamp` and `Text-to-Speech`.
- 👏🏻 2022.05.06: `PaddleSpeech Server` is available for `Audio Classification`, `Automatic Speech Recognition` and `Text-to-Speech`, `Speaker Verification` and `Punctuation Restoration`.
- 👏🏻 2022.03.28: `PaddleSpeech CLI` is available for `Speaker Verification`.
- 👏🏻 2021.12.10: `PaddleSpeech CLI` is available for `Audio Classification`, `Automatic Speech Recognition`, `Speech Translation (English to Chinese)` and `Text-to-Speech`.

### Community
- Scan the QR code below with your Wechat, you can access to official technical exchange group and get the bonus ( more than 20GB learning materials, such as papers, codes and videos ) and the live link of the lessons. Look forward to your participation.

## Installation

We strongly recommend our users to install PaddleSpeech in **Linux** with *python>=3.8* and *paddlepaddle<=2.5.1*. Some new versions of Paddle do not have support for adaptation in PaddleSpeech, so currently only versions 2.5.1 and earlier can be supported.

### **Dependency Introduction**

+ gcc >= 4.8.5
+ paddlepaddle <= 2.5.1
+ python >= 3.8
+ OS support:  Linux(recommend), Windows, Mac OSX

PaddleSpeech depends on paddlepaddle. For installation, please refer to the official website of [paddlepaddle](https://www.paddlepaddle.org.cn/en) and choose according to your own machine. Here is an example of the cpu version.

```bash
pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
```
You can also specify the version of paddlepaddle or install the develop version.
```bash
# install 2.4.1 version. Note, 2.4.1 is just an example, please follow the minimum dependency of paddlepaddle for your selection
pip install paddlepaddle==2.4.1 -i https://mirror.baidu.com/pypi/simple
# install develop version
pip install paddlepaddle==0.0.0 -f https://www.paddlepaddle.org.cn/whl/linux/cpu-mkl/develop.html
```

There are two quick installation methods for PaddleSpeech, one is pip installation, and the other is source code compilation (recommended).
### pip install

```shell
pip install pytest-runner
pip install paddlespeech
```

### source code compilation

```shell
git clone https://github.com/PaddlePaddle/PaddleSpeech.git
cd PaddleSpeech
pip install pytest-runner
pip install .
```

For more installation problems, such as conda environment, librosa-dependent, gcc problems, kaldi installation, etc., you can refer to this [installation document](./docs/source/install.md). If you encounter problems during installation, you can leave a message on [#2150](https://github.com/PaddlePaddle/PaddleSpeech/issues/2150) and find related problems

## Quick Start

Developers can have a try of our models with [PaddleSpeech Command Line](./paddlespeech/cli/README.md) or Python. Change `--input` to test your own audio/text and support 16k wav format audio.

**You can also quickly experience it in AI Studio 👉🏻 [PaddleSpeech API Demo](https://aistudio.baidu.com/aistudio/projectdetail/4353348?sUid=2470186&shared=1&ts=1660876445786)**

Test audio sample download

```shell
wget -c https://paddlespeech.bj.bcebos.com/PaddleAudio/zh.wav
wget -c https://paddlespeech.bj.bcebos.com/PaddleAudio/en.wav
```

### Automatic Speech Recognition

 （Click to expand）Open Source Speech Recognition

**command line experience**

```shell
paddlespeech asr --lang zh --input zh.wav
```

**Python API experience**

```python
>>> from paddlespeech.cli.asr.infer import ASRExecutor
>>> asr = ASRExecutor()
>>> result = asr(audio_file="zh.wav")
>>> print(result)
我认为跑步最重要的就是给我带来了身体健康
```

### Text-to-Speech

 Open Source Speech Synthesis

Output 24k sample rate wav format audio

**command line experience**

```shell
paddlespeech tts --input "你好，欢迎使用百度飞桨深度学习框架！" --output output.wav
```

**Python API experience**

```python
>>> from paddlespeech.cli.tts.infer import TTSExecutor
>>> tts = TTSExecutor()
>>> tts(text="今天天气十分不错。", output="output.wav")
```
- You can experience in [Huggingface Spaces](https://huggingface.co/spaces) [TTS Demo](https://huggingface.co/spaces/KPatrick/PaddleSpeechTTS)

### Audio Classification

 An open-domain sound classification tool

Sound classification model based on 527 categories of AudioSet dataset

**command line experience**

```shell
paddlespeech cls --input zh.wav
```

**Python API experience**

```python
>>> from paddlespeech.cli.cls.infer import CLSExecutor
>>> cls = CLSExecutor()
>>> result = cls(audio_file="zh.wav")
>>> print(result)
Speech 0.9027186632156372
```

### Voiceprint Extraction

 Industrial-grade voiceprint extraction tool

**command line experience**

```shell
paddlespeech vector --task spk --input zh.wav
```

**Python API experience**

```python
>>> from paddlespeech.cli.vector import VectorExecutor
>>> vec = VectorExecutor()
>>> result = vec(audio_file="zh.wav")
>>> print(result) # 187维向量
[ -0.19083306   9.474295   -14.122263    -2.0916545    0.04848729
   4.9295826    1.4780062    0.3733844   10.695862     3.2697146
  -4.48199     -0.6617882   -9.170393   -11.1568775   -1.2358263 ...]
```

### Punctuation Restoration

 Quick recovery of text punctuation, works with ASR models

**command line experience**

```shell
paddlespeech text --task punc --input 今天的天气真不错啊你下午有空吗我想约你一起去吃饭
```

**Python API experience**

```python
>>> from paddlespeech.cli.text.infer import TextExecutor
>>> text_punc = TextExecutor()
>>> result = text_punc(text="今天的天气真不错啊你下午有空吗我想约你一起去吃饭")
今天的天气真不错啊！你下午有空吗？我想约你一起去吃饭。
```

### Speech Translation

 End-to-end English to Chinese Speech Translation Tool

Use pre-compiled kaldi related tools, only support experience in Ubuntu system

**command line experience**

```shell
paddlespeech st --input en.wav
```

**Python API experience**

```python
>>> from paddlespeech.cli.st.infer import STExecutor
>>> st = STExecutor()
>>> result = st(audio_file="en.wav")
['我 在 这栋 建筑 的 古老 门上 敲门 。']
```

## Quick Start Server

Developers can have a try of our speech server with [PaddleSpeech Server Command Line](./paddlespeech/server/README.md).

**You can try it quickly in AI Studio (recommend): [SpeechServer](https://aistudio.baidu.com/aistudio/projectdetail/4354592?sUid=2470186&shared=1&ts=1660877827034)**

**Start server**

```shell
paddlespeech_server start --config_file ./demos/speech_server/conf/application.yaml
```

**Access Speech Recognition Services**

```shell
paddlespeech_client asr --server_ip 127.0.0.1 --port 8090 --input input_16k.wav
```

**Access Text to Speech Services**

```shell
paddlespeech_client tts --server_ip 127.0.0.1 --port 8090 --input "您好，欢迎使用百度飞桨语音合成服务。" --output output.wav
```

**Access Audio Classification Services**
```shell
paddlespeech_client cls --server_ip 127.0.0.1 --port 8090 --input input.wav
```

For more information about server command lines, please see: [speech server demos](https://github.com/PaddlePaddle/PaddleSpeech/tree/develop/demos/speech_server)

## Quick Start Streaming Server

Developers can have a try of  [streaming asr](./demos/streaming_asr_server/README.md) and [streaming tts](./demos/streaming_tts_server/README.md) server.

**Start Streaming Speech Recognition Server**

```
paddlespeech_server start --config_file ./demos/streaming_asr_server/conf/application.yaml
```

**Access Streaming Speech Recognition Services**

```
paddlespeech_client asr_online --server_ip 127.0.0.1 --port 8090 --input input_16k.wav
```

**Start Streaming Text to Speech  Server**

```
paddlespeech_server start --config_file ./demos/streaming_tts_server/conf/tts_online_application.yaml
```

**Access Streaming Text to Speech Services**

```
paddlespeech_client tts_online --server_ip 127.0.0.1 --port 8092 --protocol http --input "您好，欢迎使用百度飞桨语音合成服务。" --output output.wav
```

For more information please see:  [streaming asr](./demos/streaming_asr_server/README.md) and [streaming tts](./demos/streaming_tts_server/README.md)

## Model List

PaddleSpeech supports a series of most popular models. They are summarized in [released models](./docs/source/released_model.md) and attached with available pretrained models.

**Speech-to-Text** contains *Acoustic Model*, *Language Model*, and *Speech Translation*, with the following details:

      Speech-to-Text Module Type
      Dataset
      Model Type
      Example

      Speech Recogination
      Aishell
      DeepSpeech2 RNN + Conv based Models

      deepspeech2-aishell

      Transformer based Attention Models

      u2.transformer.conformer-aishell

       Librispeech
      Transformer based Attention Models

      deepspeech2-librispeech / transformer.conformer.u2-librispeech  / transformer.conformer.u2-kaldi-librispeech

      TIMIT
      Unified Streaming & Non-streaming Two-pass

     u2-timit

  Alignment
  THCHS30
  MFA

  mfa-thchs30

      Language Model
      Ngram Language Model

      kenlm

      Speech Translation (English to Chinese)
      TED En-Zh
      Transformer + ASR MTL

      transformer-ted

      FAT + Transformer + ASR MTL

      fat-st-ted

**Text-to-Speech** in PaddleSpeech mainly contains three modules: *Text Frontend*, *Acoustic Model* and *Vocoder*. Acoustic Model and Vocoder models are listed as follow:

       Text-to-Speech Module Type
       Model Type
       Dataset
       Example

       Text Frontend

      tn / g2p

      Acoustic Model
      Tacotron2
      LJSpeech / CSMSC

      tacotron2-ljspeech / tacotron2-csmsc

      Transformer TTS
      LJSpeech

      transformer-ljspeech

      SpeedySpeech
      CSMSC

      speedyspeech-csmsc

      FastSpeech2
      LJSpeech / VCTK / CSMSC / AISHELL-3 / ZH_EN / finetune

      fastspeech2-ljspeech / fastspeech2-vctk / fastspeech2-csmsc / fastspeech2-aishell3 / fastspeech2-zh_en / fastspeech2-finetune

      ERNIE-SAT
      VCTK / AISHELL-3 / ZH_EN

      ERNIE-SAT-vctk / ERNIE-SAT-aishell3 / ERNIE-SAT-zh_en

      DiffSinger
      Opencpop

      DiffSinger-opencpop

      Vocoder
      WaveFlow
      LJSpeech

      waveflow-ljspeech

      Parallel WaveGAN
      LJSpeech / VCTK / CSMSC / AISHELL-3 / Opencpop

      PWGAN-ljspeech / PWGAN-vctk / PWGAN-csmsc /  PWGAN-aishell3 / PWGAN-opencpop

      Multi Band MelGAN
      CSMSC

      Multi Band MelGAN-csmsc

      Style MelGAN
      CSMSC

      Style MelGAN-csmsc

      HiFiGAN
      LJSpeech / VCTK / CSMSC / AISHELL-3 / Opencpop

      HiFiGAN-ljspeech / HiFiGAN-vctk / HiFiGAN-csmsc / HiFiGAN-aishell3 / HiFiGAN-opencpop

      WaveRNN
      CSMSC

      WaveRNN-csmsc

      Voice Cloning
      GE2E
      Librispeech, etc.

      GE2E

      SV2TTS (GE2E + Tacotron2)
      AISHELL-3

      VC0

      SV2TTS (GE2E + FastSpeech2)
      AISHELL-3

      VC1

      SV2TTS (ECAPA-TDNN + FastSpeech2)
      AISHELL-3

      VC2

      GE2E + VITS
      AISHELL-3

      VITS-VC

      End-to-End
      VITS
      CSMSC / AISHELL-3

      VITS-csmsc / VITS-aishell3

**Audio Classification**

       Task
       Dataset
       Model Type
       Example

      Audio Classification
      ESC-50
      PANN

      pann-esc50

**Keyword Spotting**

       Task
       Dataset
       Model Type
       Example

      Keyword Spotting
      hey-snips
      MDTC

      mdtc-hey-snips

**Speaker Verification**

       Task
       Dataset
       Model Type
       Example

      Speaker Verification
      VoxCeleb1/2
      ECAPA-TDNN

      ecapa-tdnn-voxceleb12

**Speaker Diarization**

       Task
       Dataset
       Model Type
       Example

      Speaker Diarization
     AMI
      ECAPA-TDNN + AHC / SC

      ecapa-tdnn-ami

**Punctuation Restoration**

       Task
       Dataset
       Model Type
       Example

      Punctuation Restoration
      IWLST2012_zh
      Ernie Linear

      iwslt2012-punc0

## Documents

Normally, [Speech SoTA](https://paperswithcode.com/area/speech), [Audio SoTA](https://paperswithcode.com/area/audio) and [Music SoTA](https://paperswithcode.com/area/music) give you an overview of the hot academic topics in the related area. To focus on the tasks in PaddleSpeech, you will find the following guidelines are helpful to grasp the core ideas.

- [Installation](./docs/source/install.md)
- [Quick Start](#quickstart)
- [Some Demos](./demos/README.md)
- Tutorials
  - [Automatic Speech Recognition](./docs/source/asr/quick_start.md)
    - [Introduction](./docs/source/asr/models_introduction.md)
    - [Data Preparation](./docs/source/asr/data_preparation.md)
    - [Ngram LM](./docs/source/asr/ngram_lm.md)
  - [Text-to-Speech](./docs/source/tts/quick_start.md)
    - [Introduction](./docs/source/tts/models_introduction.md)
    - [Advanced Usage](./docs/source/tts/advanced_usage.md)
    - [Chinese Rule Based Text Frontend](./docs/source/tts/zh_text_frontend.md)
    - [Test Audio Samples](https://paddlespeech.readthedocs.io/en/latest/tts/demo.html)
  - Speaker Verification
    - [Audio Searching](./demos/audio_searching/README.md)
    - [Speaker Verification](./demos/speaker_verification/README.md)
  - [Audio Classification](./demos/audio_tagging/README.md)
  - [Speech Translation](./demos/speech_translation/README.md)
  - [Speech Server](./demos/speech_server/README.md)
- [Released Models](./docs/source/released_model.md)
  - [Speech-to-Text](#SpeechToText)
  - [Text-to-Speech](#TextToSpeech)
  - [Audio Classification](#AudioClassification)
  - [Speaker Verification](#SpeakerVerification)
  - [Speaker Diarization](#SpeakerDiarization)
  - [Punctuation Restoration](#PunctuationRestoration)
- [Community](#Community)
- [Welcome to contribute](#contribution)
- [License](#License)

The Text-to-Speech module is originally called [Parakeet](https://github.com/PaddlePaddle/Parakeet), and now merged with this repository. If you are interested in academic research about this task, please see [TTS research overview](https://github.com/PaddlePaddle/PaddleSpeech/tree/develop/docs/source/tts#overview). Also, [this document](https://github.com/PaddlePaddle/PaddleSpeech/blob/develop/docs/source/tts/models_introduction.md) is a good guideline for the pipeline components.

## ⭐ Examples
- **[PaddleBoBo](https://github.com/JiehangXie/PaddleBoBo): Use PaddleSpeech TTS to generate virtual human voice.**

- [PaddleSpeech Demo Video](https://paddlespeech.readthedocs.io/en/latest/demo_video.html)

- **[VTuberTalk](https://github.com/jerryuhoo/VTuberTalk): Use PaddleSpeech TTS and ASR to clone voice from videos.**

## Citation

To cite PaddleSpeech for research, please use the following format.

```text
@inproceedings{zhang2022paddlespeech,
    title = {PaddleSpeech: An Easy-to-Use All-in-One Speech Toolkit},
    author = {Hui Zhang, Tian Yuan, Junkun Chen, Xintong Li, Renjie Zheng, Yuxin Huang, Xiaojie Chen, Enlei Gong, Zeyu Chen, Xiaoguang Hu, dianhai yu, Yanjun Ma, Liang Huang},
    booktitle = {Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies: Demonstrations},
    year = {2022},
    publisher = {Association for Computational Linguistics},
}

@InProceedings{pmlr-v162-bai22d,
  title = {{A}$^3${T}: Alignment-Aware Acoustic and Text Pretraining for Speech Synthesis and Editing},
  author = {Bai, He and Zheng, Renjie and Chen, Junkun and Ma, Mingbo and Li, Xintong and Huang, Liang},
  booktitle = {Proceedings of the 39th International Conference on Machine Learning},
  pages = {1399--1411},
  year = {2022},
  volume = {162},
  series = {Proceedings of Machine Learning Research},
  month = {17--23 Jul},
  publisher = {PMLR},
  pdf = {https://proceedings.mlr.press/v162/bai22d/bai22d.pdf},
  url = {https://proceedings.mlr.press/v162/bai22d.html},
}

@inproceedings{zheng2021fused,
  title={Fused acoustic and text encoding for multimodal bilingual pretraining and speech translation},
  author={Zheng, Renjie and Chen, Junkun and Ma, Mingbo and Huang, Liang},
  booktitle={International Conference on Machine Learning},
  pages={12736--12746},
  year={2021},
  organization={PMLR}
}
```

## Contribute to PaddleSpeech

You are warmly welcome to submit questions in [discussions](https://github.com/PaddlePaddle/PaddleSpeech/discussions) and bug reports in [issues](https://github.com/PaddlePaddle/PaddleSpeech/issues)! Also, we highly appreciate if you are willing to contribute to this project!

### Contributors

## Acknowledgement
- Many thanks to [HighCWu](https://github.com/HighCWu) for adding [VITS-aishell3](./examples/aishell3/vits) and [VITS-VC](./examples/aishell3/vits-vc) examples.
- Many thanks to [david-95](https://github.com/david-95) for fixing multi-punctuation bug、contributing to multiple program and data, and adding [SSML](https://github.com/PaddlePaddle/PaddleSpeech/discussions/2538) for TTS Chinese Text Frontend.
- Many thanks to [BarryKCL](https://github.com/BarryKCL) for improving TTS Chinses Frontend based on [G2PW](https://github.com/GitYCC/g2pW).
- Many thanks to [yeyupiaoling](https://github.com/yeyupiaoling)/[PPASR](https://github.com/yeyupiaoling/PPASR)/[PaddlePaddle-DeepSpeech](https://github.com/yeyupiaoling/PaddlePaddle-DeepSpeech)/[VoiceprintRecognition-PaddlePaddle](https://github.com/yeyupiaoling/VoiceprintRecognition-PaddlePaddle)/[AudioClassification-PaddlePaddle](https://github.com/yeyupiaoling/AudioClassification-PaddlePaddle) for years of attention, constructive advice and great help.
- Many thanks to [mymagicpower](https://github.com/mymagicpower) for the Java implementation of ASR upon [short](https://github.com/mymagicpower/AIAS/tree/main/3_audio_sdks/asr_sdk) and [long](https://github.com/mymagicpower/AIAS/tree/main/3_audio_sdks/asr_long_audio_sdk) audio files.
- Many thanks to [JiehangXie](https://github.com/JiehangXie)/[PaddleBoBo](https://github.com/JiehangXie/PaddleBoBo) for developing Virtual Uploader(VUP)/Virtual YouTuber(VTuber) with PaddleSpeech TTS function.
- Many thanks to [745165806](https://github.com/745165806)/[PaddleSpeechTask](https://github.com/745165806/PaddleSpeechTask) for contributing Punctuation Restoration model.
- Many thanks to [kslz](https://github.com/745165806) for supplementary Chinese documents.
- Many thanks to [awmmmm](https://github.com/awmmmm) for contributing fastspeech2 aishell3 conformer pretrained model.
- Many thanks to [phecda-xu](https://github.com/phecda-xu)/[PaddleDubbing](https://github.com/phecda-xu/PaddleDubbing) for developing a dubbing tool with GUI based on PaddleSpeech TTS model.
- Many thanks to [jerryuhoo](https://github.com/jerryuhoo)/[VTuberTalk](https://github.com/jerryuhoo/VTuberTalk) for developing a GUI tool based on PaddleSpeech TTS and code for making datasets from videos based on PaddleSpeech ASR.
- Many thanks to [vpegasus](https://github.com/vpegasus)/[xuesebot](https://github.com/vpegasus/xuesebot) for developing a rasa chatbot,which is able to speak and listen thanks to PaddleSpeech.
- Many thanks to [chenkui164](https://github.com/chenkui164)/[FastASR](https://github.com/chenkui164/FastASR) for the C++ inference implementation of PaddleSpeech ASR.
- Many thanks to [heyudage](https://github.com/heyudage)/[VoiceTyping](https://github.com/heyudage/VoiceTyping) for the real-time voice typing tool implementation of PaddleSpeech ASR streaming services.
- Many thanks to [EscaticZheng](https://github.com/EscaticZheng)/[ps3.9wheel-install](https://github.com/EscaticZheng/ps3.9wheel-install) for the python3.9 prebuilt wheel for PaddleSpeech installation in Windows without Viusal Studio.
Besides, PaddleSpeech depends on a lot of open source repositories. See [references](./docs/source/reference.md) for more information.
- Many thanks to [chinobing](https://github.com/chinobing)/[FastAPI-PaddleSpeech-Audio-To-Text](https://github.com/chinobing/FastAPI-PaddleSpeech-Audio-To-Text) for converting audio to text based on FastAPI and PaddleSpeech.
- Many thanks to [MistEO](https://github.com/MistEO)/[Pallas-Bot](https://github.com/MistEO/Pallas-Bot) for QQ bot based on PaddleSpeech TTS.

## License

PaddleSpeech is provided under the [Apache-2.0 License](./LICENSE).

## Stargazers over time

[![Stargazers over time](https://starchart.cc/PaddlePaddle/PaddleSpeech.svg)](https://starchart.cc/PaddlePaddle/PaddleSpeech)


**[dbt](https://www.getdbt.com/)** enables data analysts and engineers to transform their data using the same practices that software engineers use to build applications.

![architecture](https://github.com/dbt-labs/dbt-core/blob/202cb7e51e218c7b29eb3b11ad058bd56b7739de/etc/dbt-transform.png)

## Understanding dbt

Analysts using dbt can transform their data by simply writing select statements, while dbt handles turning these statements into tables and views in a data warehouse.

These select statements, or "models", form a dbt project. Models frequently build on top of one another – dbt makes it easy to [manage relationships](https://docs.getdbt.com/docs/ref) between models, and [visualize these relationships](https://docs.getdbt.com/docs/documentation), as well as assure the quality of your transformations through [testing](https://docs.getdbt.com/docs/testing).

![dbt dag](https://raw.githubusercontent.com/dbt-labs/dbt-core/6c6649f9129d5d108aa3b0526f634cd8f3a9d1ed/etc/dbt-dag.png)

## Getting started

- [Install dbt Core](https://docs.getdbt.com/docs/get-started/installation) or explore the [dbt Cloud CLI](https://docs.getdbt.com/docs/cloud/cloud-cli-installation), a command-line interface powered by [dbt Cloud](https://docs.getdbt.com/docs/cloud/about-cloud/dbt-cloud-features) that enhances collaboration.
- Read the [introduction](https://docs.getdbt.com/docs/introduction/) and [viewpoint](https://docs.getdbt.com/docs/about/viewpoint/)

## Join the dbt Community

- Be part of the conversation in the [dbt Community Slack](http://community.getdbt.com/)
- Read more on the [dbt Community Discourse](https://discourse.getdbt.com)

## Reporting bugs and contributing code

- Want to report a bug or request a feature? Let us know and open [an issue](https://github.com/dbt-labs/dbt-core/issues/new/choose)
- Want to help us build dbt? Check out the [Contributing Guide](https://github.com/dbt-labs/dbt-core/blob/HEAD/CONTRIBUTING.md)

## Code of Conduct

Everyone interacting in the dbt project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [dbt Code of Conduct](https://community.getdbt.com/code-of-conduct).


# qFit 2024v2

![](https://github.com/ExcitedStates/qfit-3.0/workflows/tests/badge.svg)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

qFit is a collection of programs for modeling multi-conformer protein structures.

Electron density maps obtained from high-resolution X-ray diffraction data are a spatial and temporal average of all conformations within the crystal. qFit evaluates an extremely large number of combinations of sidechain conformers, backbone fragments and small-molecule ligands to locally explain the electron density.

If you use this software, please cite:
- [Wankowicz SA, Ravikumar A, Sharma S, Riley BT, Raju A, Hogan DW, van den Bedem H, Keedy DA, & Fraser JS. Uncovering Protein Ensembles: Automated Multiconformer Model Building for X-ray Crystallography and Cryo-EM. eLife. (2023).](https://www.biorxiv.org/content/10.1101/2023.06.28.546963v2.abstract)
- [Riley BT, Wankowicz SA, et al. qFit 3: Protein and ligand multiconformer modeling for X-ray crystallographic and single-particle cryo-EM density maps. Protein Sci. 30, 270–285 (2021)](https://dx.doi.org/10.1002/pro.4001)
- [van Zundert, G. C. P. et al. qFit-ligand Reveals Widespread Conformational Heterogeneity of Drug-Like Molecules in X-Ray Electron Density Maps. J. Med. Chem. 61, 11183–11198 (2018)](https://dx.doi.org/10.1021/acs.jmedchem.8b01292)
- [Keedy, D. A., Fraser, J. S. & van den Bedem, H. Exposing Hidden Alternative Backbone Conformations in X-ray Crystallography Using qFit. PLoS Comput. Biol. 11, e1004507 (2015)](https://dx.doi.org/10.1371/journal.pcbi.1004507)

As this software relies on CVXPY, please also cite:
- [Agrawal, Verschueren, Diamond, & Boyd. A Rewriting System for Convex Optimization Problems. Journal of Control and Decision. (2018).](https://arxiv.org/abs/1709.04494)
- [Diamond & Boyd. CVXPY: A Python-Embedded Modeling Language for Convex Optimization. Journal of Machine Learning Research. (2016)](https://www.jmlr.org/papers/volume17/15-408/15-408.pdf)

## Installation

## Installation (conda recommended)

We recommend using the _conda_ package manager to install _qFit_.

You will need the following tools:

* git
* _conda_ package manager (which you can get by installing [Miniconda3](https://docs.conda.io/en/latest/miniconda.html))

Once these are installed, you can:

1. Create a new conda env & activate it
   ```bash
   conda create --name qfit "python>=3.9"
   conda activate qfit
   ```

1. Install dependencies
   ```bash
   conda install -c anaconda mkl numpy=1.22
   pip install cvxpy
   pip install PySCIPOpt
   ```
   For some of the post analysis scripts, you will also need sklean
   conda install -c anaconda scikit-learn

1. Clone the latest release of the qFit source, and install to your conda env
   ```bash
   git clone -b main https://github.com/ExcitedStates/qfit-3.0.git
   cd qfit-3.0
   pip install .
   ```

1. You're now ready to run qFit programs! See [usage examples](#sec:usage-examples) below for some examples.

### M1 Macs

Unfortunately, the Anaconda repos don't contain 'osx-arm64' binaries for IBM's CPLEX and Intel's mkl.
We don't currently have plans to switch to a different MIQP solver (e.g. Gurobi).

As a workaround, you'll have to force conda to install the 'osx-64' binaries for everything (x86_64).
macOS's Rosetta 2 translation will handle the Intel→AppleSilicon translation.

Instead of the first step in the above Installation section, use this:

1. Create a new conda env & activate it
   ```bash
   CONDA_SUBDIR=osx-64 conda create --name qfit "python>=3.9"
   conda activate qfit; conda env config vars set CONDA_SUBDIR=osx-64; conda deactivate
   conda activate qfit
   ```

then follow the rest of the instructions.
### Advanced

If you prefer to manage your environments using other methods, qFit has the following prerequisites:

* [Python 3.6+](https://python.org)
* [numpy](https://numpy.org)
* [scipy](https://scipy.org)
* [cvxpy](https://www.cvxpy.org)

Once dependencies are installed, you can clone the qFit source, and install to your env as above.

## Contributing

qFit uses [Black](https://github.com/psf/black) to format its code and provides a git hook to verify that code is properly formatted before allowing you to commit.

Before creating a commit, you will have to perform two actions:
1. Install Black, either through a package manager or by running `python3 -m pip install --user black`
2. Run `git config core.hooksPath .githooks/` to use the provided pre-commit hook

## Usage examples

The `qfit` package comes with several command line tools to model alternate
conformers into electron densities. You should select the command line tool that
is most suited for your task. Please refer below for a basic usage example. More specialized and advanced use case examples
are shown in [TUTORIAL](example/README.md) in the [example](example/) directory.

To remove single-conformer model bias, qFit should be used with a composite omit
map. One way of generating such map is using the [Phenix software suite](https://www.phenix-online.org/):

`phenix.composite_omit_map input.mtz model.pdb omit-type=refine`

An example test case (3K0N) can be found in the [qfit protein example](example/qfit_protein_example/) directory. Additionally, you can find the Cryo-EM example (PDB: 7A4M) and the qFit-ligand example (PDB: 4MS6) in the *example* directory.

### Recommended settings

To model alternate conformers for all residues in a *X-ray crystallography* model using qFit,
the following command should be used:

`qfit_protein [COMPOSITE_OMIT_MAP_FILE] -l [LABELS] [PDB_FILE] -p [# OF THREADS]`

This command will produce a multiconformer model that spans the entirety of the
input target protein. The final model, with consistent labeling of multiple conformers
is output into *multiconformer_model2.pdb*. This file should then
be used as input to the post-qFit refinement script provided in [scripts](scripts/post) folder.

qFit can be run on a single thread, but speeds up significantly with multiple threads. Do to this, use the *-p* flag.

If you wish to specify a different directory for the output, this can be done
using the flag *-d*.

By default, qFit expects the labels FWT,PHWT to be present in the input map.
Different labels can be set accordingly using the flag *-l*.

Using the example 3K0N:

`qfit_protein example/qfit_protein_example/3k0n_map.mtz -l 2FOFCWT,PH2FOFCWT example/qfit_protein_example/3k0n_refine.pdb`

After *multiconformer_model2.pdb* has been generated, refine this model using:

`qfit_final_refine_xray.sh example/qfit_protein_example/3k0n_structure_factors.mtz example/qfit_protein_example/multiconformer_model2.pdb`

Additionally, the qFit_occupancy.params file must exist in the folder.

(A pre-generated multiconformer_model2.pdb file is available in the [qfit protein example](example/qfit_protein_example/) folder)

Bear in mind that this final step currently depends on an existing installation
of the Phenix software suite. This script is currently written to work with version Phenix 1.20.

To model alternate conformers for all residues in a *cryo-EM* model using qFit,
the following command should be used:

`qfit_protein [MAP_FILE] -r [RES] [PDB_FILE] -em`

After *multiconformer_model2.pdb* has been generated, refine this model using:

`qfit_final_refine_cryoEM.sh example/qfit_protein_example/em_map.ccp4 example/qfit_protein_example/multiconformer_model2.pdb example/qfit_protein_example/input_pdb_file.pdb`

More advanced features of qFit (modeling single residue, more advanced options, and further explainations) are explained in [TUTORIAL](example/README.md).

## License

The code is licensed under the MIT licence (see `LICENSE`).

Several modules were taken from the `pymmlib` package, originally licensed
under the Artistic License 2.0. See the `licenses` directory for a copy of the
original source code and its full license.

The `elements.py` is licensed under MIT, Copyright (c) 2005-2015, Christoph
Gohlke. See file header.

The `Xpleo` software and `LoopTK` package have been major inspirations for the inverse kinematics
functionality.


About the AnacondaRecipes/aggregate repository
==============================================

The aggregate repository contains:

-  The global `conda-build variant config <https://docs.conda.io/projects/conda-build/en/latest/resources/variants.html#creating-conda-build-variant-config-files>`_ file: `conda_build_config.yaml <https://github.com/AnacondaRecipes/aggregate/blob/master/conda_build_config.yaml>`_ (similar to the `conda-forge-pinnings-feedstock <https://github.com/conda-forge/conda-forge-pinning-feedstock/blob/master/recipe/conda_build_config.yaml>`_)
-  A central list of all public maintained feedstocks:

   -  most feedstocks are separate feedstock repositories:

      -  They are referenced as git submodule with relative repository URL and their release branches: `.gitmodules <https://github.com/AnacondaRecipes/aggregate/blob/master/.gitmodules>`_. (similar to ``conda-forge`` feedstocks repository)
      -  The quality on the referenced release branches is ensured via *Pull Requests* and *Automated builds*. The latest commit can be checked out via: ``git submodule update --init --remote $feedstock-folder`` (``--remote`` is important as the submodule pinning to a specific sha1 of the referenced repository is often not updated.)

   -  some feedstocks are normal directories checked into aggregate: aggregate serves here as staging area for recipes that eventually need to be submitted to ``conda-forge`` or for recipes that we think ``conda-forge`` will have no interest in.

How to add new recipes to the aggregate repository
--------------------------------------------------

Unfortunately, because of the structure of this organization, where each recipe has its own repository, there is no way to submit a PR that adds a new recipe, because PRs can’t create repositories, only modify existing ones. If you’d like to submit a recipe for us to build and make available on the default channel, you can either:

-  Submit your recipe to conda-forge’s staged-recipes repository (https://github.com/conda-forge/staged-recipes). There are directions in `the readme here <https://github.com/conda-forge/staged-recipes#getting-started>`_. When your recipe is merged and has become a feedstock repository, file an issue on the ``AnacondaRecipes/aggregate`` repo and we can fork that feedstock repository and build it.
-  Add your recipe in a folder on the aggregate repository. **This is generally something we’d like to avoid.** It does not benefit from the automated CI building that ``conda-forge`` does. It also mixes up the git history for your recipe with everything else that happens to the aggregate repository. We’ll still consider recipes submitted this way, but please consider it a last resort.

How to change recipes on the aggregate repository
-------------------------------------------------

Most recipes in the aggregate repository are submodules - essentially links to other repositories. To submit changes to recipes, it is best to fork those other repositories, submit PRs to them, and then we’ll update the aggregate’s link to the changed recipe. We prefer PRs to be submitted to ``conda-forge`` recipes, because their automatic CI builds help us know that your changes don’t cause any unintended breakage. Once your changes are incorporated at conda-forge, file an issue on the ``AnacondaRecipes/aggregate`` repo and we’ll pull them into our recipe on AnacondaRecipes.

For the few recipes that exist as folders on the aggregate repo, clone the aggregate repo, and issue PRs against it directly.

How to build python + packages once a new version of Python arrives (on ppc)
----------------------------------------------------------------------------

::

  CONDA_ADD_PIP_AS_PYTHON_DEPENDENCY=0 \
    conda-build $(cat python-order.txt | \
        sed '/^python-feedstock/,$!d' | \
        grep -v '# \[not ppc\]' | \
        sed 's/[[:space:]].*$//' | tr '\n' ' ') \
      -c local \
      -c https://repo.anaconda.com/pkgs/main \
      --skip-existing --error-overlinking 2>&1 | \
    tee -a ~/conda/python-3.7.0-all-build-out.log


# Cray System Management Documentation

* [Scope and audience](#scope-and-audience)
* [Table of contents](#table-of-contents)
* [Copyright and license](#copyright-and-license)

## Scope and audience

The documentation included here describes the Cray System Management (CSM) software, how to install
or upgrade CSM software, and related supporting operational procedures to manage an HPE Cray EX system.
CSM software is the foundation upon which other software product streams for the HPE Cray EX system depend.

The CSM installation prepares and deploys a distributed system across a group of management
nodes organized into a Kubernetes cluster which uses Ceph for utility storage. These nodes
perform their function as Kubernetes master nodes, Kubernetes worker nodes, or utility storage
nodes with the Ceph storage.

System services on these nodes are provided as containerized micro-services packaged for deployment
via Helm charts. Kubernetes orchestrates these services and schedules them on Kubernetes worker
nodes with horizontal scaling. Horizontal scales increases or decreases the number of service instances as
demand for them varies, such as when booting many compute nodes or application nodes.

This information is intended for system installers, system administrators, and network administrators
of the system. It assumes some familiarity with standard Linux and open source tools, such as shell
scripts, revision control with git, configuration management with Ansible, YAML, JSON, and TOML file formats, etc.

## Table of contents

1. [Introduction to CSM Installation](introduction/README.md)

   This chapter provides an introduction to using the CSM software to manage the HPE Cray EX system which
   also describes the scenarios for installation and upgrade of CSM software, how product stream updates
   for CSM are delivered, the operational activities done after installation for on-going management
   of the HPE Cray EX system, differences between previous release and this release, and conventions
   used in this documentation.

1. [Bare-Metal Steps](operations/bare_metal/Bare-Metal.md)

   This chapter outlines how to set up default credentials for River BMCs and
   ServerTech PDUs, which must be done before the initial installation of
   CSM, in order to enable HSM software to interact with River Redfish BMCs
   and PDUs.

1. [Update CSM Product Stream](update_product_stream/README.md)

   This chapter explains how to get the CSM product release, get any patches, update to the latest
   documentation, and check for any Field Notices or Hotfixes.

1. [Install CSM](install/README.md)

   This chapter provides an ordered list of procedures to follow when performing an initial install
   or a reinstall of CSM software. See the separate "Upgrade CSM" chapter for upgrade procedures.

1. [Upgrade CSM](upgrade/README.md)

   This chapter provides an ordered list of procedures which can be used to update CSM software that
   indicate when to do operational tasks as part of the software upgrade workflow. See the separate
   "Install CSM" chapter for initial install and reinstall procedures.

1. [CSM Operational Activities](operations/README.md)

   This chapter provides an unordered set of administrative procedures required to operate an HPE Cray EX system with CSM software and grouped into several major areas:
   * CSM Product Management
   * Artifact Management
   * Boot Orchestration
   * Compute Rolling Upgrade
   * Configuration Management
   * Console Management
   * Firmware Management
   * Hardware State Manager
   * Image Management
   * Kubernetes
   * Network Management
   * Node Management
   * Package Repository Management
   * Power Management
   * Resiliency
   * River Endpoint Discovery Service
   * Security And Authentication
   * System Configuration Service
   * System Layout Service
   * System Management Health
   * Utility Storage
   * Validate CSM Health

1. [CSM Troubleshooting Information](troubleshooting/README.md)

   This chapter provides information about some known issues in the system and tips for troubleshooting Kubernetes.

1. [CSM Background Information](background/README.md)

   This chapter provides background information about the NCNs (non-compute nodes) which function as
   management nodes for the HPE Cray EX system. This information is not normally needed to install
   or upgrade software, but provides background which might be helpful for troubleshooting an installation.

1. [CSM REST API Documentation](api/README.md)

    This chapter provides documentation on the REST APIs of the services in CSM.

1. [Glossary](glossary.md)

   This chapter provides explanations of terms and acronyms used throughout the rest of this documentation.

## Copyright and license

See [LICENSE](LICENSE).


[comment]: <> ()

| CI           | [![GitHub Workflow Status][github-ci-badge]][github-ci-link] [![Code Coverage Status][codecov-badge]][codecov-link]          |
| :----------- | :--------------------------------------------------------------------------------------------------------------------------: |
| **Docs**     |                                                                    [![Documentation Status][rtd-badge]][rtd-link]            |
| **Package**  |                                                         [![Conda][conda-badge]][conda-link] [![PyPI][pypi-badge]][pypi-link] |
| **License**  |                                                                        [![License][license-badge]][repo-link]                |
| **Citing**   |                                                                              [![DOI][doi-badge]][doi-link]                   |

UXarray aims to address the geoscience community's need for tools that enable
standard data analysis techniques to operate directly on unstructured grid
data. UXarray provides Xarray-styled functionality to better read in and use
unstructured grid datasets that follow standard conventions, including UGRID,
MPAS, SCRIP, ESMF, and Exodus grid formats. This effort is a result of the
collaboration between Project Raijin (NSF NCAR and Pennsylvania State University)
and the SEATS Project (Argonne National Laboratory, UC Davis, and Lawrence
Livermore National Laboratory). The UXarray team welcomes community
members to become part of this collaboration at any level of contribution.

UXarray is implemented in pure Python and does not explicitly contain or require
any compiled code. This makes UXarray more accessible to the general Python
community. Any contributions to this repository in pure Python are welcome and
documentation for contribution guidelines can be found when clicking `New Issue`
under the `Issues` tab in the UXarray repository.

## Why is the name "UXarray"?

We have created UXarray based on [Xarray](https://docs.xarray.dev/en/stable/)
(via inheritance of Xarray Dataset and DataArray classes), a Pangeo ecosystem package
commonly-used for structured grids recognition, to support reading and
recognizing unstructured grid model outputs. We picked the name "UXarray"
(pronounced "you-ex-array") and preferred to capitalize the first two letters to
emphasize it builds upon Xarray for Unstructured grids.

## UXarray Functionality

The following intended functionality has been inspired by discussions with
members of the scientific community, within the SEATS Project and Project
Raijin, and on several community platforms such as [Xarray GitHub
Repository](https://github.com/pydata/xarray/issues/4222). The UXarray team
is receptive to additional functionality requests.

## Intended Functionality for Grids

* Support for reading and writing UGRID, SCRIP ESMF, and Exodus formatted grids.
* Support for reading and writing shapefiles.
* Support for arbitrary structured and unstructured grids on the sphere,
  including latitude-longitude grids, grids with only partial coverage of
  the sphere, and grids with concave faces.
* Support for finite volume and finite element outputs.
* Support for edges that are either great circle arcs or lines of constant
  latitude.
* Calculation of face areas, centroids, and bounding latitude-longitude boxes.
* Triangular decompositions.
* Calculation of supermeshes (consisting of grid lines from two input grids).

## Intended Functionality for DataArrays on Grids

* Regridding of data between unstructured grids.
* Global and regional integration of fields, including zonal averages.
* Application of calculus operations, including divergence, curl, Laplacian
  and gradient.
* Snapshots and composites following particular features.

## Documentation

[UXarray Documentation](https://uxarray.readthedocs.io/en/latest)

[Contributor’s Guide](https://uxarray.readthedocs.io/en/latest/contributing.html)

[Installation](https://uxarray.readthedocs.io/en/latest/installation.html)

[Project Raijin Homepage](https://raijin.ucar.edu/)

[SEATS Project Homepage](https://seatstandards.org)

## Citing UXarray

If you'd like to cite our work, please follow [How to cite
UXarray](https://uxarray.readthedocs.io/en/latest/citation.html).

## Support

    Project Raijin, entitled "Collaborative Research: EarthCube Capabilities: Raijin: Community Geoscience Analysis Tools for Unstructured Mesh Data", was awarded by NSF 21-515 EarthCube (Award Number (FAIN): 2126458) on 08/19/2021. The award period of performance has a start date of 09/01/2021 and end date of 08/31/2024.

    SEATS is funded by the Regional and Global Modeling and Analysis (RGMA) program area in the U.S. Department of Energy (DOE) Earth and Environmental System Modeling Program which is part of the Earth and Environmental Systems Sciences Division of the Office of Biological and Environmental Research in DOE’s Office of Science.

    EarthCube aims to transform the conduct of geosciences research by developing and maintaining a well-connected and facile environment that improves access, sharing, visualization, and analysis of data and related resources.

    Pangeo supports collaborative efforts to develop software and infrastructure to enable Big Data geoscience research.

[github-ci-badge]: https://img.shields.io/github/actions/workflow/status/UXARRAY/uxarray/ci.yml?branch=main&label=CI&logo=github&style=for-the-badge
[github-ci-link]: https://github.com/UXARRAY/uxarray/actions?query=workflow%3ACI
[codecov-badge]: https://img.shields.io/codecov/c/github/UXARRAY/uxarray.svg?logo=codecov&style=for-the-badge
[codecov-link]: https://codecov.io/gh/UXARRAY/uxarray
[rtd-badge]: https://img.shields.io/readthedocs/uxarray/latest.svg?style=for-the-badge
[rtd-link]: https://uxarray.readthedocs.io/en/latest/?badge=latest
[pypi-badge]: https://img.shields.io/pypi/v/uxarray?logo=pypi&style=for-the-badge
[pypi-link]: https://pypi.org/project/uxarray
[conda-badge]: https://img.shields.io/conda/vn/conda-forge/uxarray
[conda-link]: https://anaconda.org/conda-forge/uxarray
[license-badge]: https://img.shields.io/github/license/UXARRAY/uxarray?style=for-the-badge
[doi-badge]: https://zenodo.org/badge/421447986.svg
[doi-link]: https://zenodo.org/badge/latestdoi/421447986
[repo-link]: https://github.com/UXARRAY/uxarray


[![Build Status](https://travis-ci.com/StanfordAHA/garnet.svg?branch=master)](https://travis-ci.com/StanfordAHA/garnet)
[![codecov](https://codecov.io/gh/stanfordaha/garnet/branch/master/graph/badge.svg?token=9XcZmGqxyt)](https://codecov.io/gh/stanfordaha/garnet)

This repo lets you investigate and experiment with implementing our CGRA using new generator infrastructure. Here you will find: original Genesis2 source for top level modules, functional models, and testing infrastructure. Also, you will find common generator patterns abstracted away to make designing, testing, and programming the CGRA faster.

# Usage

Once garnet is installed, you can build e.g. a 2x2 CGRA simply by doing
```
$ python garnet.py --help
$ python garnet.py --width 4 --height 2
```
For installation instructions, read on.

# Install and Build (also see issue https://github.com/StanfordAHA/garnet/issues/1037)

  We use a docker environment to build the chip. Here's how:

### Use AHA repo to boot up a docker image and container
```
$ git clone https://github.com/StanfordAHA/aha aha
$ cd aha; git submodule init update --recursive
$ docker build . -t aha_image           # May need sudo depending on your setup
$ docker exec -it aha_container bash    # May need sudo depending on your setup
```

### (Inside docker now) build a 4x2 CGRA `garnet.v`
```
$ source /aha/bin/activate
$ cd /aha/garnet
$ python garnet.py --width 4 --height 2 --verilog
```

## Verify functionality
We can verify that everything is setup properly by running the test suite using
pytest.
```
$ cd /aha; ./garnet/.github/scripts/run_pytest.sh
```
(FYI last time I tried this it did not work until I first did `cd /aha/garnet; git checkout master` ...?)

# Style guide

Please read and follow the
[style guide in the AHA wiki](https://github.com/StanfordAHA/aha/wiki/Style-Guide).


# Hotsos

Use hotsos to implement repeatable analysis and extract useful information from common cloud applications and subsystems. Write analysis Scenarios using a high-level language and helpful Python libraries. A catalog of analysis implementations is included.

The design of hotsos is oriented around “plugins” that provide easy access to the state of applications and subsystems. Hotsos is run against a Data Root which can either be the host it is run on or a sosreport. The output is a summary containing key information from each plugin along with any issuses or known bugs detected and suggestions on what actions can be taken to handle them.

## Documentation

Installation and Usage: https://hotsos.readthedocs.io/en/latest/install/index.html

Contributing: https://hotsos.readthedocs.io/en/latest/contrib/index.html

Full documentation: https://hotsos.readthedocs.io/en/latest/


=================
Full documentation at: http://ifiscripts.readthedocs.io/en/latest/index.html
=================
.. inclusion-marker-do-not-remove
.. image:: http://readthedocs.org/projects/ifiscripts/badge/?version=latest

Introduction
============

Summary
-------

These scripts facilitate collections management workflows within the IFI Irish Film Archive.
These scripts have been tested in OSX & Mac OS, Windows 7 & 10 & 11, Ubuntu 14.04 & 16.04 & 18.04.
They are mostly Python 3.7 compatible but some are still Python 2.7 only.

They are located here on github: https://github.com/Irish-Film-Institute/IFIscripts

An installation package version is available on PyPI: https://pypi.org/project/ifiscripts/.
The scripts included can be found in ``setup.py`` or ``pyproject.toml``.
To install: run ``pip(3) install ifiscripts`` in the terminal.

Most scripts have ArgumentParser so you can run `$ifiscript.py -h` to check the usage.
Some scripts without ArgumentParser take either a file or a directory as their input, for
example ``makeffv1.py filename.mov`` or
``premis.py path/to/folder_of_stuff``.
For all the arguments requiring a path, it's best to just drag and drop
the folder or filename into the terminal as this provides the absolute path.

We want the project to be as reuseable as possible in different institutions and contexts. Some scripts, particularly anything to do with ``Object Entry`` or ``Accessioning`` will be quite IFI specific, but other scripts such as ``makeffv1.py``, ``dcpaccess.py`` and many others have been used in a variety of contexts in several different countries.

The project uses the MIT license, and we encourage the reuse, modification and study of the scripts. It's always nice to hear when the scripts have been reused in some way, but it's not necessary to let us know.

Purpose
-------

These python scripts facilitate much of our collections management procedures for digitised and born digital objects in the Irish Film Institute. We utilise a lot of open source tools, so we wanted to make these scripts as open as possible. This is why this project has the MIT License.

The Irish Film Institute has followed the SPECTRUM museum collections management standard for several years. These scripts attempt to follow SPECTRUM procedures while also utilising some of the concepts of the Open Archival Information System (OAIS). Initially the scripts only handled single video files, but they are now capable of handling:

* Digital Cinema Packages
* XDCAM cards
* DPX/TIFF image sequences
* Documents (.doc, .pdf etc)
* Images (.jpg, .TIFF etc)

An example workflow might be:

* A digital object is created or acquired by the IFI, and ``ingest`` begins.

* ``sipcreator.py`` is run on the object. This script:
   * generates an ``Object Entry`` identifier (eg OE-1234)
   * creates a folder structure for ``logs, metadata, objects``
   * generates a ``UUID``, extracts technical metadata
   * generates a md5 checksum manifest
   * and see the usage section for more.

* All of these preservation events are logged in a log file located in the ``logs`` directory. This log file tries to use ``PREMIS (PREservation Metadata Implementation Strategies)`` terminology as much as possible.

* Even though the package has yet to be accessioned, temporary backups are required. ``copyit.py`` will generate backups, and it will use the checksum manifest generated by ``sipcreator.py`` to verify the integrity of the file transfer.

* If the package contains FFV1 or Matroska files, perhaps ``ffv1mkvvalidate.py`` could run, which uses ``mediaconch`` to verify the compliance of the files, and stores the information in the logfile.

* If the package passes our Quality Control Procedures, then it will be accessioned. ``aipcreator.py`` will generate an accession number, rename the OE number with the accession number, generate a SHA-512 manifest and update the log file to document these new preservation events.

* A large batch of items can be AIPed using ``batchaipcreator.py``. If the ``-pbcore`` command line argument is used with the aipcreator scripts, technical metadata based on the PBCore standard will be generated in CSV format. This process can be run seperately by using ``makepbcore.py``. CSV was chosen instead of XML as this allows us to immediately import the CSV into our database system so that we have item level records.

* Access copies may be needed, so low-res watermarked proxies can be generated with ``bitc.py``, or high res mezzanines with ``prores.py``.

* The AIP can then be written to preservation storage, again using the ``copyit.py`` command.

So this is just one way of using the scripts from acquisition to preservation storage, but there are many other scripts for specific workflows, which you can investigate further down in the documentation.

Table of Contents
-----------------

.. toctree::
   :maxdepth: 4
   :caption: Contents:

   installation
   contributing
   usage
   credits


# Dug: digging up dark data

Dug applies semantic web and knowledge graph methods to improve the [FAIR](https://www.go-fair.org/fair-principles/)-ness of research data.

As an example, [dbGaP](https://www.ncbi.nlm.nih.gov/gap/) is a rich source of metadata about biomedical knowledge derived from clinical research like the underutilized [TOPMed](https://www.nhlbiwgs.org/) data sets. A key obstacle to leveraging this knowledge is the lack of researcher tools to navigate from a set of concepts of interest towards relevant study variables. In a word, **search**.

While other approaches to searching this data exist, our focus is semantic search: For us, "relevant" is defined as having a basis in curated, peer reviewed ontologically represented biomedical knowledge. Given a search term, Dug returns results that are related based on connections in ontological biomedical knowledge graphs.

To achieve this, we annotate study metadata with terms from [biomedical ontologies](http://www.obofoundry.org/), contextualize them within a unifying [upper ontology](https://biolink.github.io/biolink-model/) allowing study data to be federated with [larger knowledge graphs](https://researchsoftwareinstitute.github.io/data-translator/), and create a full text search index based on those knowledge graphs.

## Quickstart

NOTE: You must run `make init` once you've cloned the repo to enable the commit-msg git hook so that conventional commits will apply automatically.

To install Dug in your environment , run `make install`. Alternatively,

```shell
pip install -r requirements.txt
pip install -e .
```

To run the tests , run `make test`. Alternatively,

```shell
pytest .
```

(The makefile currently only executes unit tests,
whereas running pytest in the root directory will execute unit tests, integration tests, and doctests)

To bring up the backend services, run:

```shell
docker-compose up
```

If you're running dug-specific commands (i.e. `dug`) outside the docker container,
you have to make sure the env vars are set. Also, make sure all hostnames are correct
for the environment you're running in. For example, to be able to connect to dug backend
services from outside the container (but in a shell env), run:

```shell
source .env
export $(cut -d= -f1 .env)
export ELASTIC_API_HOST=localhost
export REDIS_HOST=localhost
```

(These values are already set up in the running docker container)

Then you can actually crawl the data:

```shell
dug crawl tests/integration/data/test_variables_v1.0.csv -p "TOPMedTag"
````

After crawling, you can search:
```shell
dug search -q "vein" -t "concepts"
dug search -q "vein" -t "variables" -k "concept=UBERON:0001638"
```

You can also query Dug's REST API:
```shell
query="`echo '{"index" : "concepts_index", "query" : "vein"}'`"

curl --data "$query" \
     --header "Content-Type: application/json" \
     --request POST \
     http://localhost:5551/search
```

### Additional Notes

If you want to change or re-configure the dug service authentication credentials
to be different from the defaults, run:

```shell
mv .env .env.bak
DATA_DIR=/path/to/dug-data-storage RANDOM=$RANDOM envsubst < .env.template > .env
docker-compose down
docker system prune -a  # NOTE: This will remove *all* images, layers, and volumes.
                        #       Be sure you're okay with this before running.
docker-compose up
```

## The Dug Framework

Dug's **ingest** uses the [Biolink](https://biolink.github.io/biolink-model/) upper ontology to annotate knowledge graphs and structure queries used to drive full text indexing and search. It uses Monarch Initiative APIs to perform named entity recognition on natural language prose to extract ontology identifiers. It also uses Translator normalization services to find preferred identifiers and Biolink types for each extracted identifier. The final step of ingest is to represent the annotated data in a Neo4J graph database.

Dug's **integration** phase uses Translator's Plater and Automat to generate a Reasoner Standard API compliant service and integrates that service into TranQL. This enables queries that span TOPMed, ROBOKOP, and other reasoners.

Dug's **indexing & search** phase query the graph infrastructure and analyze the resulting graphs. These are used to create documents associating natural language terms with annotations and the annotated variables and studies.
![image](https://user-images.githubusercontent.com/306971/94348055-4eb22180-0007-11eb-8093-4e321735ebaf.png)

Dug will then generate Translator knowledge sources for the annotated variables and present them for query via TranQL.

## Knowledge Graphs

Dug's core data structure is the knowledge graph. Here's a query of a COPDGene knowledge graph created by Dug from harmonized TOPMed variables.

![image](https://user-images.githubusercontent.com/306971/77009445-513c0c00-693e-11ea-83ed-722ec896d3e9.png)
**Figure 1**: A Biolink knowledge graph of COPDGene metadata. It shows the relationship between the biological process "Sleep" and a meta variable. The highlighted node is aTOPMed meta variable or harmonized variable. It is in turn associated with variables connected to two studies in the data set. By linking additional ontological terms to the biological process sleep, we will be able to provde progressively more helpful search results rooted in curated biomedical knowledge.

And one more example to illustrate the knowledge model we use to inform the search index:
![image](https://user-images.githubusercontent.com/306971/77230029-b9ba0180-6b67-11ea-9ccf-748955aa1931.png)
**Figure 2**: The TOPMed harmonized variable is highlighted, showing its relationships with the ontology term for Heart Failure and the Heart Failure and with a specific study variable. Several similar disease, harmonized variable, variable, study relationships are also shown.

These graphs are used to create the document's well add to the search index to power full text search.

In phase 1, we use Neo4J to build queries. In subsequent phases, we integrate other semantic services using TranQL.

![image](https://user-images.githubusercontent.com/306971/77681466-bcec2d80-6f6b-11ea-93c5-87eee57d4b66.png)
**Figure 3**: A TranQL knowledge graph query response. Integrating TOPMed harmonized variables as a Translator service called by TranQL allows us to query the federation of Translator ontological connections as a precursor to indexing. This includes chemical, phenotypic, disease, cell type, genetic, and other ontologies from sources like [ROBOKOP](https://researchsoftwareinstitute.github.io/data-translator/apps/robokop) as well as clinical aggregate data from sources like [ICEES](https://researchsoftwareinstitute.github.io/data-translator/apps/icees). The image above shows a query linking cholesterol to "LDL in Blood" a harmonized TOPMed variable. That variable is, in turn, linked to source variables and each of those is linked to its source study.

## Elasticsearch Logic

Elasticsearch contains the indexed knowledge graphs against which we perform full-text queries.  Our query currently supports conditionals (AND, OR, NOT) as well as exact matching on quoted terms.  Because we don't specify an analyzer in our query or when we index documents, we default to the [standard analyzer](https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-standard-analyzer.html), which is recommended for full-text search.  The standard analyzer performs grammar-based tokenization (e.g., splitting up an input string into tokens by several separators including whitespace, commas, hyphens), defined by the [Unicode Standard Annex #29](http://unicode.org/reports/tr29/).

### Example Documents and Query Behavior

Two toy examples of indexed documents, `blood_color` and `blood_shape`, are shown below to demonstrate query behavior.

![image](https://user-images.githubusercontent.com/63300314/85741468-7627e400-b6d0-11ea-849c-7b6da8b630b3.png)

#### Query
The query searches the fields in all indexed documents to return a matching subset of documents.

```
query = {
            'query_string': {
                'query' : query,
                'fuzziness' : fuzziness,
                'fields': ['name', 'description', 'instructions', 'nodes.name', 'nodes.synonyms'],
                'quote_field_suffix': ".exact"
            }
        }
````

#### Tests

| Query|Behavior|
| :--- |  :---- |
| **blood** | This returns both documents (`blood_color` and `blood_shape`). |
| **blood AND magenta**  | This returns only `blood_color`. |
| **magenta AND cerulean** | This returns `blood_color` even though this might be unexpected.  The words 'magenta' and 'cerulean' appear in the same document in the searched fields, even though they appear in different fields, so the document is still returned. |
| **blue AND square** | No documents are returned. |
| **blue and square** | This returns both documents because the 'and' term is treated as just another term instead of an operator because it is not capitalized.  The actual search resolves to **blue OR and OR square** |
| **"round blood"** | No documents are returned. |
| **"blood, round"** | This returns `blood_shape`|
| **"blood round"** | The document `blood_shape` is returned - the standard analyzer performs tokenization based on grammar separators, including commas in this case. |

## Approach

The methodology, from start to finish, reads raw data, annotates it with ontological terms, normalizes those terms, inserts them into a queryable knowledge graph, queries that graph along pre-configured lines, turns the resulting knowledge graphs into documents, and indexes those documents in a full text search engine.

### Link

Link ingests raw dbGaP study metadata and performs semantic annotation by
* Parsing a TOPMed data dictionary XML file to extract variables.
* Using the Monarch SciGraph named entity recognizer to identify ontology terms.
* Using the Translator SRI identifier normalization service to
  * Select a preferred identifier for the entity
  * Determine the BioLink types applying to each entity
* Writing each variable with its annotations as a JSON object to a file.

### Load

* Converts the annotation format written in the steps above to a KGX graph
* Inserts that graph into a Neo4J database.

In phase-1, we query Neo4J to create knowledge graphs. In phase-2 we'll use the Neo4J to create a Translator Knowledge Provider API. That API will be integrated using TranQL with other Translator reasoners like ROBOKOP. This will allow us to build more sophisticated graphs spanning federated ontological knowledge.

### Crawl

* Runs those graph queries and caches knowledge graph responses.

### Index

* Consumes knowledge graphs produced by the crawl.
* Uses connections in the graph to create documents including both full text of variable descriptions and ontology terms.
* Produces a queryable full text index of the variable set.

### Search API

* Presents an OpenAPI compliant REST interface
* Provides a scalable microservice suitable as an Internet endpoint.

## The Dug Data Development Kit (DDK)

Dug provides a tool chain for the ingest, annotation, knowledge graph representation, query, crawling, indexing, and search of datasets with metadata. The following sections provide an overview of the relevant components.

### Ingest

Data formats for harmonized variables appear to be in flux, hence the multiple approaches. More on this soon.

| Command           | Description                                         | Example                  |
| ----------------- | --------------------------------------------------- | ------------------------ |
| bin/dug link      | Use NLP, etc to add ontology identifiers and types. | bin/dug link {input}     |
| bin/dug load      | Create a knowledge graph database.                  | bin/dug load {input}     |

There are three sets of example metadata files in the repo.
* A COPDGene dbGaP metadata file is at `data/dd.xml`
* A harmonized variable metadata CSV is at `data/harmonized_variable_DD.csv`
* Files with names starting with: `data/topmed_*`

This last format seems to be the go-forward TOPMed harmonized variable form.

These can be run with
```
bin/dug link data/dd.xml
bin/dug load data/dd_tagged.json
```
or
```
bin/dug link data/harmonized_variable_DD.csv
bin/dug load data/harmoinzed_variable_DD_tagged.json
```
or
```
bin/dug link data/topmed_variables_v1.0.csv [--index x]
```
The first two formats will likely go away.
The last format
* Consists of two sets of files following that naming convention.
* Combines the link and load phases into link.
* Optionally allows the --index <arg> flag. This will run graph queries and index data in Elasticsearch.

### Crawl & Index

| Command        | Description                                                       | Example              |
| -------------- | ----------------------------------------------------------------- | -------------------- |
| bin/dug crawl  | Execute graph queries and accumulate knowledge graphs in response.| bin/dug crawl        |
| bin/dug index  | Analyze crawled knowledge graphs and create search engine indices.| bin/dug index        |
| bin/dug query  | Test the index by querying the search engine from Python.         | bin/dug query {text} |

### Search API

Exposing the Elasticsearch interface to the internet is strongly discouraged for security reasons. Instead, we have a REST API. We'll use this as a place to enforce a schema and validate requests so that the search engine's network endpoint is strictly internal.
| Command        | Description           | Example                              |
| -------------- | --------------------- | ------------------------------------ |
| bin/dug api    | Run the REST API.     | bin/dug api [--debug] [--port={int}] |

To call the API endpoint using curl:
| Command             | Description           | Example                   |
| ------------------- | --------------------- | ------------------------- |
| bin/dug query_api   | Call the REST API.    | bin/dug query_api {query} |

## Development

A docker-compose is provided that runs four services:
* Redis
* Neo4J
* Elasticsearch
* The Dug search OpenAPI

This system can be started with the following command:

| Command             | Description                | Example          |
| ------------------- | -------------------------- | ---------------- |
| bin/dug stack       | Runs all services          | bin/dug stack    |

**Developers:** Internal to bin/dug, an environment file is automatically created. That file is in `docker/.env`.
If you are running in development, and are not using a public IP address and hostname, you'll want to create a separate .env file to allow programs to connect to the docker containers as services. This matters if, for example, you want to run bin/test, as the clients in that test need to know how to connect to each of the services they call. Copy the generated docker/.env to docker/.env.dev. Change all hostnames to `localhost`. That should do it. Be sure to keep the generated passwords from the generated .env the same.

## Testing

Dug's automated functional tests:
* Delete the test index
* Execute the link and load phases for the dbGaP data dictionary and harmonized variables.
* Execute the crawl and index phases.
* Execute a number of searches over the generated search index.

| Command             | Description                    | Example      |
| ------------------- | ------------------------------ | ------------ |
| bin/dug test        | Run automated functional tests | bin/dug test |

Once the test is complete, a command line search shows the contents of the index:
![image](https://user-images.githubusercontent.com/306971/77009780-e939f580-693e-11ea-8a02-ca2fd59d4366.png)
**Figure 4**: A command line query using the Dug Search OpenAPI to query the Elasticsearch index for a term.

## Data Formats

TOPMed phenotypic concept data is [here](https://github.com/helxplatform/dug/tree/master/data).

## Release

To release, commit the change and select feature.

#### Fail on Vulnerability Detection

During PR's several vulnerability scanners are run. If there are vulnerabilities detected, the pr checks will fail and a report will be sent to Github Security Dashboard for viewing. Please ensure the vulnerability is mitigated prior to continuing the merge to protected branches.