Upload 12 files

.gitignore

@@ -0,0 +1,11 @@
+*.pyc
+__pycache__
+test.py
+flagged
+output
+gradio_cached*
+*egg-info
+build*
+*.wav
+dist/
+*DS_Store*

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2023 Scott Chacon and others
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

MANIFEST.in

@@ -0,0 +1,2 @@
+include *.py LICENSE README.md
+recursive-include audiosr *.txt *.py *.gz *.npy *.json

README.md

@@ -1,13 +1,95 @@
----
-title: Hyghds98f6g7
-emoji: 🌍
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# AudioSR: Versatile Audio Super-resolution at Scale
+
+[![arXiv](https://img.shields.io/badge/arXiv-2309.07314-brightgreen.svg?style=flat-square)](https://arxiv.org/abs/2309.07314)  [![githubio](https://img.shields.io/badge/GitHub.io-Audio_Samples-blue?logo=Github&style=flat-square)](https://audioldm.github.io/audiosr) [![Replicate](https://replicate.com/nateraw/audio-super-resolution/badge)](https://replicate.com/nateraw/audio-super-resolution)
+
+Pass your audio in, AudioSR will make it high fidelity! 
+
+Work on all types of audio (e.g., music, speech, dog, raining, ...) & all sampling rates.
+
+Share your thoughts/samples/issues in our discord channel: https://discord.gg/HWeBsJryaf
+
+![Image Description](https://github.com/haoheliu/versatile_audio_super_resolution/blob/main/visualization.png?raw=true)
+
+## Change Log
+- 2024-12-16: Add [Important things to know to make AudioSR work](example/how_to_make_audiosr_work.md).
+- 2023-09-24: Add replicate demo (@nateraw); Fix error on windows, librosa warning etc (@ORI-Muchim).  
+- 2023-09-16: Fix DC shift issue. Fix duration padding bug. Update default DDIM steps to 50.
+
+## Gradio Demo
+
+To run the Gradio demo locally:
+
+1. Install dependencies: `pip install -r requirements.txt` 
+2. Run the app: `python app.py`
+3. Open the URL displayed to view the demo
+
+## Commandline Usage
+
+## Installation
+```shell
+# Optional
+conda create -n audiosr python=3.9; conda activate audiosr
+# Install AudioLDM
+pip3 install audiosr==0.0.7
+# or
+# pip3 install git+https://github.com/haoheliu/versatile_audio_super_resolution.git
+```
+
+## Usage
+
+Process a list of files. The result will be saved at ./output by default.
+
+```shell
+audiosr -il batch.lst
+```
+
+Process a single audio file.
+```shell
+audiosr -i example/music.wav
+```
+
+Full usage instruction
+
+```shell
+> audiosr -h
+
+> usage: audiosr [-h] -i INPUT_AUDIO_FILE [-il INPUT_FILE_LIST] [-s SAVE_PATH] [--model_name {basic,speech}] [-d DEVICE] [--ddim_steps DDIM_STEPS] [-gs GUIDANCE_SCALE] [--seed SEED]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -i INPUT_AUDIO_FILE, --input_audio_file INPUT_AUDIO_FILE
+                        Input audio file for audio super resolution
+  -il INPUT_FILE_LIST, --input_file_list INPUT_FILE_LIST
+                        A file that contains all audio files that need to perform audio super resolution
+  -s SAVE_PATH, --save_path SAVE_PATH
+                        The path to save model output
+  --model_name {basic,speech}
+                        The checkpoint you gonna use
+  -d DEVICE, --device DEVICE
+                        The device for computation. If not specified, the script will automatically choose the device based on your environment.
+  --ddim_steps DDIM_STEPS
+                        The sampling step for DDIM
+  -gs GUIDANCE_SCALE, --guidance_scale GUIDANCE_SCALE
+                        Guidance scale (Large => better quality and relavancy to text; Small => better diversity)
+  --seed SEED           Change this value (any integer number) will lead to a different generation result.
+  --suffix SUFFIX       Suffix for the output file
+```
+
+
+## TODO
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/haoheliuP)
+
+- [ ] Add gradio demo.
+- [ ] Optimize the inference speed.
+
+## Cite our work
+If you find this repo useful, please consider citing: 
+```bibtex
+@article{liu2023audiosr,
+  title={{AudioSR}: Versatile Audio Super-resolution at Scale},
+  author={Liu, Haohe and Chen, Ke and Tian, Qiao and Wang, Wenwu and Plumbley, Mark D},
+  journal={arXiv preprint arXiv:2309.07314},
+  year={2023}
+}
+```

app.py

@@ -0,0 +1,29 @@
+import gradio as gr
+from audiosr import super_resolution, build_model
+
+def inference(audio_file, model_name, guidance_scale, ddim_steps):
+    audiosr = build_model(model_name=model_name)
+    
+    waveform = super_resolution(
+        audiosr,
+        audio_file,
+        guidance_scale=guidance_scale,
+        ddim_steps=ddim_steps
+    )
+    
+    return (44100, waveform)
+
+iface = gr.Interface(
+    fn=inference, 
+    inputs=[
+        gr.Audio(type="filepath", label="Input Audio"),
+        gr.Dropdown(["basic", "speech"], value="basic", label="Model"),
+        gr.Slider(1, 10, value=3.5, step=0.1, label="Guidance Scale"),  
+        gr.Slider(1, 100, value=50, step=1, label="DDIM Steps")
+    ],
+    outputs=gr.Audio(type="numpy", label="Output Audio"),
+    title="AudioSR",
+    description="Audio Super Resolution with AudioSR"
+)
+
+iface.launch()

batch.lst

@@ -0,0 +1,3 @@
+example/music.wav
+example/speech.wav
+example/sound_effect.wav

cog.yaml

@@ -0,0 +1,43 @@
+# Configuration for Cog ⚙️
+# Reference: https://github.com/replicate/cog/blob/main/docs/yaml.md
+
+build:
+  # set to true if your model requires a GPU
+  gpu: true
+  cuda: "11.7"
+
+  # a list of ubuntu apt packages to install
+  system_packages:
+    - "ffmpeg"
+    - "libsndfile1"
+
+  # python version in the form '3.8' or '3.8.12'
+  python_version: "3.9"
+
+  # a list of packages in the format <package-name>==<version>
+  python_packages:
+    - "torch==2.0.1"
+    - "torchaudio==2.0.2"
+    - "torchvision==0.15.2"
+    - "tqdm==4.66.1"
+    - "gradio==3.44.4"
+    - "pyyaml==6.0.1"
+    - "einops==0.6.1"
+    - "chardet==5.2.0"
+    - "numpy==1.23.5"
+    - "soundfile==0.12.1"
+    - "librosa==0.9.2"
+    - "scipy==1.11.2"
+    - "pandas==2.1.0"
+    - "unidecode==1.3.6"
+    - "phonemizer==3.2.1"
+    - "torchlibrosa==0.1.0"
+    - "transformers==4.30.2"
+    - "huggingface_hub==0.17.2"
+    - "progressbar==2.5"
+    - "ftfy==6.1.1"
+    - "timm==0.9.7"
+    - "audiosr==0.0.7"
+
+# predict.py defines how predictions are run on your model
+predict: "predict.py:Predictor"

inference.py

@@ -0,0 +1,235 @@
+import gc
+import os
+import random
+import numpy as np
+from scipy.signal.windows import hann
+import soundfile as sf
+import torch
+from cog import BasePredictor, Input, Path
+import tempfile
+import argparse
+import librosa
+from audiosr import build_model, super_resolution
+from scipy import signal
+import pyloudnorm as pyln
+
+
+import warnings
+warnings.filterwarnings("ignore")
+
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+torch.set_float32_matmul_precision("high")
+
+def match_array_shapes(array_1:np.ndarray, array_2:np.ndarray):
+    if (len(array_1.shape) == 1) & (len(array_2.shape) == 1):
+        if array_1.shape[0] > array_2.shape[0]:
+            array_1 = array_1[:array_2.shape[0]]
+        elif array_1.shape[0] < array_2.shape[0]:
+            array_1 = np.pad(array_1, ((array_2.shape[0] - array_1.shape[0], 0)), 'constant', constant_values=0)
+    else:
+        if array_1.shape[1] > array_2.shape[1]:
+            array_1 = array_1[:,:array_2.shape[1]]
+        elif array_1.shape[1] < array_2.shape[1]:
+            padding = array_2.shape[1] - array_1.shape[1]
+            array_1 = np.pad(array_1, ((0,0), (0,padding)), 'constant', constant_values=0)
+    return array_1
+
+
+def lr_filter(audio, cutoff, filter_type, order=12, sr=48000):
+    audio = audio.T
+    nyquist = 0.5 * sr
+    normal_cutoff = cutoff / nyquist
+    b, a = signal.butter(order//2, normal_cutoff, btype=filter_type, analog=False)
+    sos = signal.tf2sos(b, a)
+    filtered_audio = signal.sosfiltfilt(sos, audio)
+    return filtered_audio.T
+
+class Predictor(BasePredictor):
+    def setup(self, model_name="basic", device="auto"):
+        self.model_name = model_name
+        self.device = device
+        self.sr = 48000
+        print("Loading Model...")
+        self.audiosr = build_model(model_name=self.model_name, device=self.device)
+        # print(self.audiosr)
+        # exit()
+        print("Model loaded!")
+
+    def process_audio(self, input_file, chunk_size=5.12, overlap=0.1, seed=None, guidance_scale=3.5, ddim_steps=50):
+        audio, sr = librosa.load(input_file, sr=input_cutoff * 2, mono=False)
+        audio = audio.T
+        sr = input_cutoff * 2
+        print(f"audio.shape = {audio.shape}")
+        print(f"input cutoff = {input_cutoff}")
+        
+        is_stereo = len(audio.shape) == 2
+        audio_channels = [audio] if not is_stereo else [audio[:, 0], audio[:, 1]]
+        print("audio is stereo" if is_stereo else "Audio is mono")
+
+        chunk_samples = int(chunk_size * sr)
+        overlap_samples = int(overlap * chunk_samples)
+        output_chunk_samples = int(chunk_size * self.sr)
+        output_overlap_samples = int(overlap * output_chunk_samples)
+        enable_overlap = overlap > 0
+        print(f"enable_overlap = {enable_overlap}")
+        
+        def process_chunks(audio):
+            chunks = []
+            original_lengths = []
+            start = 0
+            while start < len(audio):
+                end = min(start + chunk_samples, len(audio))
+                chunk = audio[start:end]
+                if len(chunk) < chunk_samples:
+                    original_lengths.append(len(chunk))
+                    chunk = np.concatenate([chunk, np.zeros(chunk_samples - len(chunk))])
+                else:
+                    original_lengths.append(chunk_samples)
+                chunks.append(chunk)
+                start += chunk_samples - overlap_samples if enable_overlap else chunk_samples
+            return chunks, original_lengths
+
+        # Process both channels (mono or stereo)
+        chunks_per_channel = [process_chunks(channel) for channel in audio_channels]
+        sample_rate_ratio = self.sr / sr
+        total_length = len(chunks_per_channel[0][0]) * output_chunk_samples - (len(chunks_per_channel[0][0]) - 1) * (output_overlap_samples if enable_overlap else 0)
+        reconstructed_channels = [np.zeros((1, total_length)) for _ in audio_channels]
+
+        meter_before = pyln.Meter(sr)
+        meter_after = pyln.Meter(self.sr)
+        
+        # Process chunks for each channel
+        for ch_idx, (chunks, original_lengths) in enumerate(chunks_per_channel):
+            for i, chunk in enumerate(chunks):
+                loudness_before = meter_before.integrated_loudness(chunk)
+                print(f"Processing chunk {i+1} of {len(chunks)} for {'Left/Mono' if ch_idx == 0 else 'Right'} channel")
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as temp_wav:
+                    sf.write(temp_wav.name, chunk, sr)
+                
+                    out_chunk = super_resolution(
+                        self.audiosr,
+                        temp_wav.name,
+                        seed=seed,
+                        guidance_scale=guidance_scale,
+                        ddim_steps=ddim_steps,
+                        latent_t_per_second=12.8
+                    )
+
+                    out_chunk = out_chunk[0]
+                    num_samples_to_keep = int(original_lengths[i] * sample_rate_ratio)
+                    out_chunk = out_chunk[:, :num_samples_to_keep].squeeze()
+                    loudness_after = meter_after.integrated_loudness(out_chunk)
+                    out_chunk = pyln.normalize.loudness(out_chunk, loudness_after, loudness_before)
+
+                    if enable_overlap:
+                        actual_overlap_samples = min(output_overlap_samples, num_samples_to_keep)
+                        fade_out = np.linspace(1., 0., actual_overlap_samples)
+                        fade_in = np.linspace(0., 1., actual_overlap_samples)
+
+                        if i == 0:
+                            out_chunk[-actual_overlap_samples:] *= fade_out
+                        elif i < len(chunks) - 1:
+                            out_chunk[:actual_overlap_samples] *= fade_in
+                            out_chunk[-actual_overlap_samples:] *= fade_out
+                        else:
+                            out_chunk[:actual_overlap_samples] *= fade_in
+
+                    start = i * (output_chunk_samples - output_overlap_samples if enable_overlap else output_chunk_samples)
+                    end = start + out_chunk.shape[0]
+                    reconstructed_channels[ch_idx][0, start:end] += out_chunk.flatten()
+
+        reconstructed_audio = np.stack(reconstructed_channels, axis=-1) if is_stereo else reconstructed_channels[0]
+
+        if multiband_ensemble:
+            low, _ = librosa.load(input_file, sr=48000, mono=False)
+            output = match_array_shapes(reconstructed_audio[0].T, low)
+            low = lr_filter(low.T, crossover_freq, 'lowpass', order=10)
+            high = lr_filter(output.T, crossover_freq, 'highpass', order=10)
+            high = lr_filter(high, 23000, 'lowpass', order=2)
+            output = low + high
+        else:
+            output = reconstructed_audio[0]
+        # print(output, type(output))
+        return output
+
+
+    def predict(self,
+        input_file: Path = Input(description="Audio to upsample"),
+        ddim_steps: int = Input(description="Number of inference steps", default=50, ge=10, le=500),
+        guidance_scale: float = Input(description="Scale for classifier free guidance", default=3.5, ge=1.0, le=20.0),
+        overlap: float = Input(description="overlap size", default=0.04),
+        chunk_size: float = Input(description="chunksize", default=10.24),
+        seed: int = Input(description="Random seed. Leave blank to randomize the seed", default=None)
+    ) -> Path:
+
+        if seed == 0:
+            seed = random.randint(0, 2**32 - 1)
+        print(f"Setting seed to: {seed}")
+        print(f"overlap = {overlap}")
+        print(f"guidance_scale = {guidance_scale}")
+        print(f"ddim_steps = {ddim_steps}")
+        print(f"chunk_size = {chunk_size}")
+        print(f"multiband_ensemble = {multiband_ensemble}")
+        print(f"input file = {os.path.basename(input_file)}")
+        os.makedirs(output_folder, exist_ok=True)
+        waveform = self.process_audio(
+            input_file,
+            chunk_size=chunk_size,
+            overlap=overlap,
+            seed=seed,
+            guidance_scale=guidance_scale,
+            ddim_steps=ddim_steps
+        )
+        
+        filename = os.path.splitext(os.path.basename(input_file))[0]
+        sf.write(f"{output_folder}/SR_{filename}.wav", data=waveform, samplerate=48000,  subtype="PCM_16")
+        print(f"file created: {output_folder}/SR_{filename}.wav")
+        del self.audiosr, waveform
+        gc.collect()
+        torch.cuda.empty_cache()
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description="Find volume difference of two audio files.")
+    parser.add_argument("--input", help="Path to input audio file")
+    parser.add_argument("--output", help="Output folder")
+    parser.add_argument("--ddim_steps", help="Number of ddim steps", type=int, required=False, default=50)
+    parser.add_argument("--chunk_size", help="chunk size", type=float, required=False, default=10.24)
+    parser.add_argument("--guidance_scale", help="Guidance scale value",  type=float, required=False, default=3.5)
+    parser.add_argument("--seed", help="Seed value, 0 = random seed", type=int, required=False, default=0)
+    parser.add_argument("--overlap", help="overlap value", type=float, required=False, default=0.04)
+    parser.add_argument("--multiband_ensemble", type=bool, help="Use multiband ensemble with input")
+    parser.add_argument("--input_cutoff", help="Define the crossover of audio input in the multiband ensemble", type=int, required=False, default=12000)
+
+    args = parser.parse_args()
+
+    input_file_path = args.input
+    output_folder = args.output
+    ddim_steps = args.ddim_steps
+    chunk_size = args.chunk_size
+    guidance_scale = args.guidance_scale
+    seed = args.seed
+    overlap = args.overlap
+    input_cutoff = args.input_cutoff
+    multiband_ensemble = args.multiband_ensemble
+
+    crossover_freq = input_cutoff - 1000
+
+    p = Predictor()
+    
+    p.setup(device='auto')
+
+
+    out = p.predict(
+        input_file_path,
+        ddim_steps=ddim_steps,
+        guidance_scale=guidance_scale,
+        seed=seed,
+        chunk_size=chunk_size,
+        overlap=overlap
+    )
+
+    del p
+    gc.collect()
+    torch.cuda.empty_cache()

predict.py

@@ -0,0 +1,53 @@
+import os
+import random
+
+import numpy as np
+import soundfile as sf
+import torch
+from cog import BasePredictor, Input, Path
+
+from audiosr import build_model, super_resolution
+
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+torch.set_float32_matmul_precision("high")
+
+class Predictor(BasePredictor):
+    def setup(self, model_name="basic", device="auto"):
+        self.model_name = model_name
+        self.device = device
+        self.sr = 48000
+        self.audiosr = build_model(model_name=self.model_name, device=self.device)
+
+    def predict(self,
+        input_file: Path = Input(description="Audio to upsample"),
+        ddim_steps: int = Input(description="Number of inference steps", default=50, ge=10, le=500),
+        guidance_scale: float = Input(description="Scale for classifier free guidance", default=3.5, ge=1.0, le=20.0),
+        seed: int = Input(description="Random seed. Leave blank to randomize the seed", default=None)
+    ) -> Path:
+        """Run a single prediction on the model"""
+        if seed is None:
+            seed = random.randint(0, 2**32 - 1)
+            print(f"Setting seed to: {seed}")
+
+        waveform = super_resolution(
+            self.audiosr,
+            input_file,
+            seed=seed,
+            guidance_scale=guidance_scale,
+            ddim_steps=ddim_steps,
+            latent_t_per_second=12.8
+        )
+        out_wav = (waveform[0] * 32767).astype(np.int16).T
+        sf.write("out.wav", data=out_wav, samplerate=48000)
+        return Path("out.wav")
+
+
+if __name__ == "__main__":
+    p = Predictor()
+    p.setup()
+    out = p.predict(
+        "example/music.wav",
+        ddim_steps=50,
+        guidance_scale=3.5,
+        seed=42
+    )

requirements.txt

@@ -0,0 +1,16 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+git+https://github.com/huggingface/diffusers.git
+torch==2.0.1+cu118; sys_platform != 'darwin'
+torch==2.0.1; sys_platform == 'darwin'
+torchvision==0.15.2+cu118; sys_platform != 'darwin'
+torchvision==0.15.2; sys_platform == 'darwin'
+torchaudio==2.0.2+cu118; sys_platform != 'darwin'
+torchaudio==2.0.2; sys_platform == 'darwin'
+huggingface_hub
+transformers==4.30.2
+gradio
+soundfile
+progressbar
+librosa
+audiosr
+unidecode

setup.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+# python3 setup.py sdist bdist_wheel
+"""
+@File    :   setup.py.py    
+@Contact :   [email protected]
+@License :   (C)Copyright 2020-2100
+
+@Modify Time      @Author    @Version    @Desciption
+------------      -------    --------    -----------
+9/6/21 5:16 PM   Haohe Liu      1.0         None
+"""
+
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Note: To use the 'upload' functionality of this file, you must:
+#   $ pipenv install twine --dev
+
+import io
+import os
+import sys
+from shutil import rmtree
+
+from setuptools import find_packages, setup, Command
+
+# Package meta-data.
+NAME = "audiosr"
+DESCRIPTION = "This package is written for text-to-audio/music generation."
+URL = "https://github.com/haoheliu/audiosr"
+EMAIL = "[email protected]"
+AUTHOR = "Haohe Liu"
+REQUIRES_PYTHON = ">=3.7.0"
+VERSION = "0.0.7"
+
+# What packages are required for this module to be executed?
+REQUIRED = [
+    "torch>=1.13.0",
+    "torchaudio>=0.13.0",
+    "torchvision>=0.14.0",
+    "tqdm",
+    "gradio",
+    "pyyaml",
+    "einops",
+    "chardet",
+    "numpy<=1.23.5",
+    "soundfile",
+    "librosa==0.9.2",
+    "scipy",
+    "pandas",
+    "unidecode",
+    "phonemizer",
+    "torchlibrosa>=0.0.9",
+    "transformers==4.30.2",
+    "huggingface_hub",
+    "progressbar",
+    "ftfy",
+    "timm",
+]
+
+# What packages are optional?
+EXTRAS = {}
+
+# The rest you shouldn't have to touch too much :)
+# ------------------------------------------------
+# Except, perhaps the License and Trove Classifiers!
+# If you do change the License, remember to change the Trove Classifier for that!
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+# Import the README and use it as the long-description.
+# Note: this will only work if 'README.md' is present in your MANIFEST.in file!
+try:
+    with io.open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+        long_description = "\n" + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+# Load the package's __version__.py module as a dictionary.
+about = {}
+if not VERSION:
+    project_slug = NAME.lower().replace("-", "_").replace(" ", "_")
+    with open(os.path.join(here, project_slug, "__version__.py")) as f:
+        exec(f.read(), about)
+else:
+    about["__version__"] = VERSION
+
+
+class UploadCommand(Command):
+    """Support setup.py upload."""
+
+    description = "Build and publish the package."
+    user_options = []
+
+    @staticmethod
+    def status(s):
+        """Prints things in bold."""
+        print("\033[1m{0}\033[0m".format(s))
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        try:
+            self.status("Removing previous builds…")
+            rmtree(os.path.join(here, "dist"))
+        except OSError:
+            pass
+
+        self.status("Building Source and Wheel (universal) distribution…")
+        os.system("{0} setup.py sdist bdist_wheel --universal".format(sys.executable))
+
+        self.status("Uploading the package to PyPI via Twine…")
+        os.system("twine upload dist/*")
+
+        self.status("Pushing git tags…")
+        os.system("git tag v{0}".format(about["__version__"]))
+        os.system("git push --tags")
+
+        sys.exit()
+
+
+# Where the magic happens:
+setup(
+    name=NAME,
+    version=about["__version__"],
+    description=DESCRIPTION,
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author=AUTHOR,
+    author_email=EMAIL,
+    python_requires=REQUIRES_PYTHON,
+    url=URL,
+    # packages=find_packages(exclude=[]),
+    # If your package is a single module, use this instead of 'packages':
+    # entry_points={
+    #     'console_scripts': ['mycli=mymodule:cli'],
+    # },
+    install_requires=REQUIRED,
+    extras_require=EXTRAS,
+    packages=find_packages(),
+    include_package_data=True,
+    license="MIT",
+    classifiers=[
+        # Trove classifiers
+        # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+    ],
+    # $ setup.py publish support.
+    cmdclass={
+        "upload": UploadCommand,
+    },
+    scripts=["bin/audiosr.cmd", "bin/audiosr"],
+)