EXP

tools/utils/gdown.py

@@ -0,0 +1,175 @@
+import os
+import re
+import sys
+import json
+import tqdm
+import codecs
+import tempfile
+import requests
+
+from urllib.parse import urlparse, parse_qs, unquote
+
+sys.path.append(os.getcwd())
+
+from main.app.variables import translations
+
+def parse_url(url):
+    parsed = urlparse(url)
+    is_download_link = parsed.path.endswith("/uc")
+
+    if not parsed.hostname in ("drive.google.com", "docs.google.com"): return None, is_download_link
+    file_id = parse_qs(parsed.query).get("id", [None])[0]
+
+    if file_id is None:
+        for pattern in (
+            r"^/file/d/(.*?)/(edit|view)$", 
+            r"^/file/u/[0-9]+/d/(.*?)/(edit|view)$", 
+            r"^/document/d/(.*?)/(edit|htmlview|view)$", 
+            r"^/document/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$", 
+            r"^/presentation/d/(.*?)/(edit|htmlview|view)$", 
+            r"^/presentation/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$", 
+            r"^/spreadsheets/d/(.*?)/(edit|htmlview|view)$", 
+            r"^/spreadsheets/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$"
+        ):
+            match = re.match(pattern, parsed.path)
+
+            if match:
+                file_id = match.group(1)
+                break
+
+    return file_id, is_download_link
+
+def get_url_from_gdrive_confirmation(contents):
+    for pattern in (
+        r'href="(\/uc\?export=download[^"]+)', 
+        r'href="/open\?id=([^"]+)"', 
+        r'"downloadUrl":"([^"]+)'
+    ):
+        match = re.search(pattern, contents)
+
+        if match:
+            url = match.group(1)
+
+            if pattern == r'href="/open\?id=([^"]+)"': 
+                url = (
+                    codecs.decode("uggcf://qevir.hfrepbagrag.tbbtyr.pbz/qbjaybnq?vq=", "rot13") + 
+                    url + 
+                    "&confirm=t&uuid=" + 
+                    re.search(r'<input\s+type="hidden"\s+name="uuid"\s+value="([^"]+)"', contents).group(1)
+                )
+            elif pattern == r'"downloadUrl":"([^"]+)': 
+                url = (
+                    url.replace("\\u003d", "=").replace("\\u0026", "&")
+                )
+            else: 
+                url = (
+                    codecs.decode("uggcf://qbpf.tbbtyr.pbz", "rot13") + 
+                    url.replace("&", "&")
+                )
+
+            return url
+
+    match = re.search(r'<p class="uc-error-subcaption">(.*)</p>', contents)
+    if match: raise Exception(match.group(1))
+
+    raise Exception(translations["gdown_error"])
+
+def _get_session(use_cookies, return_cookies_file=False):
+    sess = requests.session()
+    sess.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)"})
+    cookies_file = os.path.join(os.path.expanduser("~"), ".cache/gdown/cookies.json")
+
+    if os.path.exists(cookies_file) and use_cookies:
+        with open(cookies_file) as f:
+            for k, v in json.load(f):
+                sess.cookies[k] = v
+
+    return (sess, cookies_file) if return_cookies_file else sess
+
+def gdown_download(url=None, output=None):
+    file_id = None
+    if url is None: raise ValueError(translations["gdown_value_error"])
+
+    if "/file/d/" in url: 
+        file_id = url.split("/d/")[1].split("/")[0]
+    elif "open?id=" in url: 
+        file_id = url.split("open?id=")[1].split("/")[0]
+    elif "/download?id=" in url: 
+        file_id = url.split("/download?id=")[1].split("&")[0]
+
+    if file_id:
+        url = f"{codecs.decode('uggcf://qevir.tbbtyr.pbz/hp?vq=', 'rot13')}{file_id}"
+        url_origin = url
+
+        sess, cookies_file = _get_session(use_cookies=True, return_cookies_file=True)
+        gdrive_file_id, is_gdrive_download_link = parse_url(url)
+
+        if gdrive_file_id:
+            url = f"{codecs.decode('uggcf://qevir.tbbtyr.pbz/hp?vq=', 'rot13')}{gdrive_file_id}"
+            url_origin = url
+            is_gdrive_download_link = True
+
+        while 1:
+            res = sess.get(url, stream=True, verify=True)
+            if url == url_origin and res.status_code == 500:
+                url = f"{codecs.decode('uggcf://qevir.tbbtyr.pbz/bcra?vq=', 'rot13')}{gdrive_file_id}"
+                continue
+
+            os.makedirs(os.path.dirname(cookies_file), exist_ok=True)
+            with open(cookies_file, "w") as f:
+                json.dump(
+                    [(k, v) for k, v in sess.cookies.items() if not k.startswith("download_warning_")], 
+                    f, 
+                    indent=2
+                )
+
+            if ("Content-Disposition" in res.headers) or (not (gdrive_file_id and is_gdrive_download_link)): break
+
+            try:
+                url = get_url_from_gdrive_confirmation(res.text)
+            except Exception as e:
+                raise Exception(e)
+
+        if gdrive_file_id and is_gdrive_download_link:
+            content_disposition = unquote(res.headers["Content-Disposition"])
+
+            filename_from_url = (
+                re.search(r"filename\*=UTF-8''(.*)", content_disposition) or re.search(r'filename=["\']?(.*?)["\']?$', content_disposition)
+            ).group(1).replace(os.path.sep, "_")
+        else: 
+            filename_from_url = os.path.basename(url)
+
+        output = os.path.join(output or ".", filename_from_url)
+        tmp_file = tempfile.mktemp(suffix=tempfile.template, prefix=os.path.basename(output), dir=os.path.dirname(output))
+        f = open(tmp_file, "ab")
+
+        if tmp_file is not None and f.tell() != 0: 
+            res = sess.get(
+                url, 
+                headers={
+                    "Range": f"bytes={f.tell()}-"
+                }, 
+                stream=True, 
+                verify=True
+            )
+
+        try:
+            with tqdm.tqdm(
+                desc=os.path.basename(output), 
+                total=int(res.headers.get("Content-Length", 0)), 
+                ncols=100, 
+                unit="byte"
+            ) as pbar:
+                for chunk in res.iter_content(chunk_size=512 * 1024):
+                    f.write(chunk)
+                    pbar.update(len(chunk))
+
+                pbar.close()
+                if tmp_file: f.close()
+        finally:
+            os.rename(tmp_file, output)
+            sess.close()
+
+        return output
+
+    return None

tools/utils/huggingface.py

@@ -0,0 +1,43 @@
+import os
+import tqdm
+import requests
+
+try:
+    import wget
+except:
+    wget = None
+
+def HF_download_file(url, output_path=None):
+    url = url.replace("/blob/", "/resolve/").replace("?download=true", "").strip()
+    output_path = (
+        os.path.basename(url) 
+    ) if output_path is None else (
+        os.path.join(output_path, os.path.basename(url)) if os.path.isdir(output_path) else output_path
+    )
+
+    if wget != None: 
+        wget.download(
+            url, 
+            out=output_path
+        )
+    else:
+        response = requests.get(url, stream=True, timeout=300)
+
+        if response.status_code == 200:
+            progress_bar = tqdm.tqdm(
+                total=int(response.headers.get("content-length", 0)), 
+                desc=os.path.basename(url), 
+                ncols=100, 
+                unit="byte", 
+                leave=False
+            )
+
+            with open(output_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=10 * 1024 * 1024):
+                    progress_bar.update(len(chunk))
+                    f.write(chunk)
+
+            progress_bar.close()
+        else: raise ValueError(response.status_code)
+
+    return output_path

tools/utils/mediafire.py

@@ -0,0 +1,43 @@
+import os
+import sys
+import requests
+
+from bs4 import BeautifulSoup
+
+def Mediafire_Download(url, output=None, filename=None):
+    if not filename: filename = url.split('/')[-2]
+    if not output: output = os.path.dirname(os.path.realpath(__file__))
+
+    output_file = os.path.join(output, filename)
+    sess = requests.session()
+    sess.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)"})
+
+    try:
+        bs4 = BeautifulSoup(
+            sess.get(url).content, 
+            "html.parser"
+        ).find(id="downloadButton").get("href")
+
+        with requests.get(
+            bs4, 
+            stream=True
+        ) as r:
+            r.raise_for_status()
+
+            with open(output_file, "wb") as f:
+                total_length = int(r.headers.get('content-length'))
+                download_progress = 0
+
+                for chunk in r.iter_content(chunk_size=1024):
+                    download_progress += len(chunk)
+                    f.write(chunk)
+
+                    stdout = f"\r[{filename}]: {int(100 * download_progress / total_length)}% ({round(download_progress / 1024 / 1024, 2)}mb/{round(total_length / 1024 / 1024, 2)}mb)"
+
+                    sys.stdout.write(stdout)
+                    sys.stdout.flush()
+
+        sys.stdout.write("\n")
+        return output_file
+    except Exception as e:
+        raise RuntimeError(e)

tools/utils/meganz.py

@@ -0,0 +1,159 @@
+import os
+import re
+import sys
+import json
+import tqdm
+import codecs
+import random
+import base64
+import struct
+import shutil
+import requests
+import tempfile
+
+from Crypto.Cipher import AES
+from Crypto.Util import Counter
+
+sys.path.append(os.getcwd())
+
+from main.app.variables import translations
+
+def makebyte(x):
+    return codecs.latin_1_encode(x)[0]
+
+def a32_to_str(a):
+    return struct.pack('>%dI' % len(a), *a)
+
+def get_chunks(size):
+    p, s = 0, 0x20000
+
+    while p + s < size:
+        yield(p, s)
+        p += s
+
+        if s < 0x100000: s += 0x20000
+
+    yield(p, size - p)
+
+def aes_cbc_decrypt(data, key):
+    aes_cipher = AES.new(key, AES.MODE_CBC, makebyte('\0' * 16))
+
+    return aes_cipher.decrypt(data)
+
+def decrypt_attr(attr, key):
+    attr = codecs.latin_1_decode(aes_cbc_decrypt(attr, a32_to_str(key)))[0].rstrip('\0')
+
+    return json.loads(attr[4:]) if attr[:6] == 'MEGA{"' else False
+
+def _api_request(data):
+    sequence_num = random.randint(0, 0xFFFFFFFF)
+    params = {'id': sequence_num}
+
+    sequence_num += 1
+    if not isinstance(data, list): data = [data]
+
+    response = requests.post(
+        '{0}://g.api.{1}/cs'.format('https', 'mega.co.nz'), 
+        params=params, 
+        data=json.dumps(data), 
+        timeout=160
+    )
+
+    json_resp = json.loads(response.text)
+    if isinstance(json_resp, int): raise Exception(json_resp)
+
+    return json_resp[0]
+
+def base64_url_decode(data):
+    data += '=='[(2 - len(data) * 3) % 4:]
+
+    for search, replace in (('-', '+'), ('_', '/'), (',', '')):
+        data = data.replace(search, replace)
+
+    return base64.b64decode(data)
+
+def str_to_a32(b):
+    if isinstance(b, str): b = makebyte(b)
+    if len(b) % 4: b += b'\0' * (4 - len(b) % 4)
+
+    return struct.unpack('>%dI' % (len(b) / 4), b)
+
+def base64_to_a32(s):
+    return str_to_a32(
+        base64_url_decode(s)
+    )
+
+def mega_download_file(file_handle, file_key, dest_path=None):
+    file_key = base64_to_a32(file_key)
+    file_data = _api_request({'a': 'g', 'g': 1, 'p': file_handle})
+
+    k = (
+        file_key[0] ^ file_key[4], 
+        file_key[1] ^ file_key[5], 
+        file_key[2] ^ file_key[6], 
+        file_key[3] ^ file_key[7]
+    )
+
+    iv = file_key[4:6] + (0, 0)
+    if 'g' not in file_data: raise Exception(translations["file_not_access"])
+
+    file_size = file_data['s']
+    attribs = decrypt_attr(base64_url_decode(file_data['at']), k)
+
+    input_file = requests.get(file_data['g'], stream=True).raw
+    temp_output_file = tempfile.NamedTemporaryFile(mode='w+b', prefix='megapy_', delete=False)
+
+    k_str = a32_to_str(k)
+    aes = AES.new(
+        k_str, 
+        AES.MODE_CTR, 
+        counter=Counter.new(
+            128, 
+            initial_value=(
+                (iv[0] << 32) + iv[1]
+            ) << 64
+        )
+    )
+
+    mac_str = b'\0' * 16
+    mac_encryptor = AES.new(k_str, AES.MODE_CBC, mac_str)
+    iv_str = a32_to_str([iv[0], iv[1], iv[0], iv[1]])
+
+    with tqdm.tqdm(total=file_size, ncols=100, unit="byte") as pbar:
+        for _, chunk_size in get_chunks(file_size):
+            chunk = aes.decrypt(input_file.read(chunk_size))
+            temp_output_file.write(chunk)
+
+            pbar.update(len(chunk))
+            encryptor = AES.new(k_str, AES.MODE_CBC, iv_str)
+
+            for i in range(0, len(chunk) - 16, 16):
+                block = chunk[i:i + 16]
+                encryptor.encrypt(block)
+
+            i = (i + 16) if file_size > 16 else 0
+            block = chunk[i:i + 16]
+
+            if len(block) % 16: block += b'\0' * (16 - (len(block) % 16))
+            mac_str = mac_encryptor.encrypt(encryptor.encrypt(block))
+
+    file_mac = str_to_a32(mac_str)
+    temp_output_file.close()
+
+    if (file_mac[0] ^ file_mac[1], file_mac[2] ^ file_mac[3]) != file_key[6:8]: raise ValueError(translations["mac_not_match"])
+
+    file_path = os.path.join(dest_path, attribs['n'])
+    if os.path.exists(file_path): os.remove(file_path)
+
+    shutil.move(temp_output_file.name, file_path)
+    return file_path
+
+def mega_download_url(url, dest_path=None):
+    if '/file/' in url:
+        url = url.replace(' ', '')
+        file_id = re.findall(r'\W\w\w\w\w\w\w\w\w\W', url)[0][1:-1]
+        path = f'{file_id}!{url[re.search(file_id, url).end() + 1:]}'.split('!')
+    elif '!' in url: path = re.findall(r'/#!(.*)', url)[0].split('!')
+    else: raise Exception(translations["missing_url"])
+
+    return mega_download_file(path[0], path[1], dest_path)

tools/utils/noisereduce.py

@@ -1,125 +1,58 @@
+import os
+import sys
 import torch
-import tempfile
-import numpy as np
 
-from joblib import Parallel, delayed
 from torch.nn.functional import conv1d, conv2d
 
-@torch.no_grad()
-def amp_to_db(x, eps = torch.finfo(torch.float32).eps, top_db = 40):
-    x_db = 20 * torch.log10(x.abs() + eps)
-    return torch.max(x_db, (x_db.max(-1).values - top_db).unsqueeze(-1))
+sys.path.append(os.getcwd())
 
 @torch.no_grad()
 def temperature_sigmoid(x, x0, temp_coeff):
-    return torch.sigmoid((x - x0) / temp_coeff)
+    return ((x - x0) / temp_coeff).sigmoid()
 
 @torch.no_grad()
 def linspace(start, stop, num = 50, endpoint = True, **kwargs):
-    return torch.linspace(start, stop, num, **kwargs) if endpoint else torch.linspace(start, stop, num + 1, **kwargs)[:-1]
-
-def _smoothing_filter(n_grad_freq, n_grad_time):
-    smoothing_filter = np.outer(np.concatenate([np.linspace(0, 1, n_grad_freq + 1, endpoint=False), np.linspace(1, 0, n_grad_freq + 2)])[1:-1], np.concatenate([np.linspace(0, 1, n_grad_time + 1, endpoint=False), np.linspace(1, 0, n_grad_time + 2)])[1:-1])
-    return smoothing_filter / np.sum(smoothing_filter)
+    return (
+        torch.linspace(
+            start, 
+            stop, 
+            num, 
+            **kwargs
+        )
+    ) if endpoint else (
+        torch.linspace(
+            start, 
+            stop, 
+            num + 1, 
+            **kwargs
+        )[:-1]
+    )
 
-class SpectralGate:
-    def __init__(self, y, sr, prop_decrease, chunk_size, padding, n_fft, win_length, hop_length, time_constant_s, freq_mask_smooth_hz, time_mask_smooth_ms, tmp_folder, use_tqdm, n_jobs):
-        self.sr = sr
-        self.flat = False
-        y = np.array(y)
-
-        if len(y.shape) == 1:
-            self.y = np.expand_dims(y, 0)
-            self.flat = True
-        elif len(y.shape) > 2: raise ValueError
-        else: self.y = y
-
-        self._dtype = y.dtype
-        self.n_channels, self.n_frames = self.y.shape
-        self._chunk_size = chunk_size
-        self.padding = padding
-        self.n_jobs = n_jobs
-        self.use_tqdm = use_tqdm
-        self._tmp_folder = tmp_folder
-        self._n_fft = n_fft
-        self._win_length = self._n_fft if win_length is None else win_length
-        self._hop_length = (self._win_length // 4) if hop_length is None else hop_length
-        self._time_constant_s = time_constant_s
-        self._prop_decrease = prop_decrease
-
-        if (freq_mask_smooth_hz is None) & (time_mask_smooth_ms is None): self.smooth_mask = False
-        else: self._generate_mask_smoothing_filter(freq_mask_smooth_hz, time_mask_smooth_ms)
-
-    def _generate_mask_smoothing_filter(self, freq_mask_smooth_hz, time_mask_smooth_ms):
-        if freq_mask_smooth_hz is None: n_grad_freq = 1
-        else:
-            n_grad_freq = int(freq_mask_smooth_hz / (self.sr / (self._n_fft / 2)))
-            if n_grad_freq < 1: raise ValueError
+@torch.no_grad()
+def amp_to_db(x, eps=torch.finfo(torch.float32).eps, top_db=40):
+    x_db = 20 * (x + eps).log10()
 
-        if time_mask_smooth_ms is None: n_grad_time = 1
-        else:
-            n_grad_time = int(time_mask_smooth_ms / ((self._hop_length / self.sr) * 1000))
-            if n_grad_time < 1: raise ValueError
+    return x_db.max(
+        (x_db.max(-1).values - top_db).unsqueeze(-1)
+    )
 
-        if (n_grad_time == 1) & (n_grad_freq == 1): self.smooth_mask = False
-        else:
-            self.smooth_mask = True
-            self._smoothing_filter = _smoothing_filter(n_grad_freq, n_grad_time)
-
-    def _read_chunk(self, i1, i2):
-        i1b = 0 if i1 < 0 else i1  
-        i2b = self.n_frames if i2 > self.n_frames else i2 
-        chunk = np.zeros((self.n_channels, i2 - i1))
-        chunk[:, i1b - i1: i2b - i1] = self.y[:, i1b:i2b]
-        return chunk
-
-    def filter_chunk(self, start_frame, end_frame):
-        i1 = start_frame - self.padding
-        return self._do_filter(self._read_chunk(i1, (end_frame + self.padding)))[:, start_frame - i1: end_frame - i1]
-
-    def _get_filtered_chunk(self, ind):
-        start0 = ind * self._chunk_size
-        end0 = (ind + 1) * self._chunk_size
-        return self.filter_chunk(start_frame=start0, end_frame=end0)
-
-    def _do_filter(self, chunk):
-        pass
-
-    def _iterate_chunk(self, filtered_chunk, pos, end0, start0, ich):
-        filtered_chunk[:, pos: pos + end0 - start0] = self._get_filtered_chunk(ich)[:, start0:end0]
-        pos += end0 - start0
-
-    def get_traces(self, start_frame=None, end_frame=None):
-        if start_frame is None: start_frame = 0
-        if end_frame is None: end_frame = self.n_frames
-
-        if self._chunk_size is not None:
-            if end_frame - start_frame > self._chunk_size:
-                ich1 = int(start_frame / self._chunk_size)
-                ich2 = int((end_frame - 1) / self._chunk_size)
-
-                with tempfile.NamedTemporaryFile(prefix=self._tmp_folder) as fp:
-                    filtered_chunk = np.memmap(fp, dtype=self._dtype, shape=(self.n_channels, int(end_frame - start_frame)), mode="w+")
-                    pos_list, start_list, end_list = [], [], []
-                    pos = 0
-
-                    for ich in range(ich1, ich2 + 1):
-                        start0 = (start_frame - ich * self._chunk_size) if ich == ich1 else 0
-                        end0 = end_frame - ich * self._chunk_size if ich == ich2 else self._chunk_size
-                        pos_list.append(pos)
-                        start_list.append(start0)
-                        end_list.append(end0)
-                        pos += end0 - start0
-
-                    Parallel(n_jobs=self.n_jobs)(delayed(self._iterate_chunk)(filtered_chunk, pos, end0, start0, ich) for pos, start0, end0, ich in zip(pos_list, start_list, end_list, range(ich1, ich2 + 1)))
-                    return filtered_chunk.astype(self._dtype).flatten() if self.flat else filtered_chunk.astype(self._dtype)
-
-        filtered_chunk = self.filter_chunk(start_frame=0, end_frame=end_frame)
-        return filtered_chunk.astype(self._dtype).flatten() if self.flat else filtered_chunk.astype(self._dtype)
-
-class TG(torch.nn.Module):
+class TorchGate(torch.nn.Module):
     @torch.no_grad()
-    def __init__(self, sr, nonstationary = False, n_std_thresh_stationary = 1.5, n_thresh_nonstationary = 1.3, temp_coeff_nonstationary = 0.1, n_movemean_nonstationary = 20, prop_decrease = 1.0, n_fft = 1024, win_length = None, hop_length = None, freq_mask_smooth_hz = 500, time_mask_smooth_ms = 50):
+    def __init__(
+        self, 
+        sr, 
+        nonstationary = False, 
+        n_std_thresh_stationary = 1.5, 
+        n_thresh_nonstationary = 1.3, 
+        temp_coeff_nonstationary = 0.1, 
+        n_movemean_nonstationary = 20, 
+        prop_decrease = 1.0, 
+        n_fft = 1024, 
+        win_length = None, 
+        hop_length = None, 
+        freq_mask_smooth_hz = 500, 
+        time_mask_smooth_ms = 50
+    ):
         super().__init__()
         self.sr = sr
         self.nonstationary = nonstationary
@@ -146,51 +79,100 @@ class TG(torch.nn.Module):
         if n_grad_time < 1: raise ValueError
         if n_grad_time == 1 and n_grad_freq == 1: return None
 
-        smoothing_filter = torch.outer(torch.cat([linspace(0, 1, n_grad_freq + 1, endpoint=False), linspace(1, 0, n_grad_freq + 2)])[1:-1], torch.cat([linspace(0, 1, n_grad_time + 1, endpoint=False), linspace(1, 0, n_grad_time + 2)])[1:-1]).unsqueeze(0).unsqueeze(0)
+        smoothing_filter = torch.outer(
+            torch.cat([
+                linspace(0, 1, n_grad_freq + 1, endpoint=False), 
+                linspace(1, 0, n_grad_freq + 2)
+            ])[1:-1], 
+            torch.cat([
+                linspace(0, 1, n_grad_time + 1, endpoint=False), 
+                linspace(1, 0, n_grad_time + 2)
+            ])[1:-1]
+        ).unsqueeze(0).unsqueeze(0)
+
         return smoothing_filter / smoothing_filter.sum()
 
     @torch.no_grad()
-    def _stationary_mask(self, X_db, xn = None):
-        XN_db = amp_to_db(torch.stft(xn, n_fft=self.n_fft, hop_length=self.hop_length, win_length=self.win_length, return_complex=True, pad_mode="constant", center=True, window=torch.hann_window(self.win_length).to(xn.device))).to(dtype=X_db.dtype) if xn is not None else X_db
-        std_freq_noise, mean_freq_noise = torch.std_mean(XN_db, dim=-1)
-        return torch.gt(X_db, (mean_freq_noise + std_freq_noise * self.n_std_thresh_stationary).unsqueeze(2))
+    def _stationary_mask(self, X_db):
+        std_freq_noise, mean_freq_noise = torch.std_mean(X_db, dim=-1)
+        return X_db > (mean_freq_noise + std_freq_noise * self.n_std_thresh_stationary).unsqueeze(2)
 
     @torch.no_grad()
     def _nonstationary_mask(self, X_abs):
-        X_smoothed = (conv1d(X_abs.reshape(-1, 1, X_abs.shape[-1]), torch.ones(self.n_movemean_nonstationary, dtype=X_abs.dtype, device=X_abs.device).view(1, 1, -1), padding="same").view(X_abs.shape) / self.n_movemean_nonstationary)
-        return temperature_sigmoid(((X_abs - X_smoothed) / X_smoothed), self.n_thresh_nonstationary, self.temp_coeff_nonstationary)
-
-    def forward(self, x, xn = None):
+        X_smoothed = (
+            conv1d(
+                X_abs.reshape(-1, 1, X_abs.shape[-1]), 
+                torch.ones(
+                    self.n_movemean_nonstationary, 
+                    dtype=X_abs.dtype, 
+                    device=X_abs.device
+                ).view(1, 1, -1), 
+                padding="same"
+            ).view(X_abs.shape) / self.n_movemean_nonstationary
+        )
+
+        return temperature_sigmoid(
+            ((X_abs - X_smoothed) / X_smoothed), 
+            self.n_thresh_nonstationary, 
+            self.temp_coeff_nonstationary
+        )
+
+    def forward(self, x):
         assert x.ndim == 2
         if x.shape[-1] < self.win_length * 2: raise Exception
-        assert xn is None or xn.ndim == 1 or xn.ndim == 2
-        if xn is not None and xn.shape[-1] < self.win_length * 2: raise Exception
-
-        X = torch.stft(x, n_fft=self.n_fft, hop_length=self.hop_length, win_length=self.win_length, return_complex=True, pad_mode="constant", center=True, window=torch.hann_window(self.win_length).to(x.device))
-        sig_mask = self._nonstationary_mask(X.abs()) if self.nonstationary else self._stationary_mask(amp_to_db(X), xn)
 
-        sig_mask = self.prop_decrease * (sig_mask * 1.0 - 1.0) + 1.0
-        if self.smoothing_filter is not None: sig_mask = conv2d(sig_mask.unsqueeze(1), self.smoothing_filter.to(sig_mask.dtype), padding="same")
+        if str(x.device).startswith(("ocl", "privateuseone")):
+            if not hasattr(self, "stft"): 
+                from main.library.backends.utils import STFT
+
+                self.stft = STFT(
+                    filter_length=self.n_fft, 
+                    hop_length=self.hop_length, 
+                    win_length=self.win_length, 
+                    pad_mode="constant"
+                ).to(x.device)
+
+            X, phase = self.stft.transform(
+                x, 
+                eps=1e-9, 
+                return_phase=True
+            )
+        else:
+            X = torch.stft(
+                x, 
+                n_fft=self.n_fft, 
+                hop_length=self.hop_length, 
+                win_length=self.win_length, 
+                return_complex=True, 
+                pad_mode="constant", 
+                center=True, 
+                window=torch.hann_window(self.win_length).to(x.device)
+            )
+            
+        sig_mask = self._nonstationary_mask(X.abs()) if self.nonstationary else self._stationary_mask(amp_to_db(X.abs()))
+        sig_mask = self.prop_decrease * (sig_mask.float() * 1.0 - 1.0) + 1.0
+
+        if self.smoothing_filter is not None: 
+            sig_mask = conv2d(
+                sig_mask.unsqueeze(1), 
+                self.smoothing_filter.to(sig_mask.dtype), 
+                padding="same"
+            )
 
         Y = X * sig_mask.squeeze(1)
-        return torch.istft(Y, n_fft=self.n_fft, hop_length=self.hop_length, win_length=self.win_length, center=True, window=torch.hann_window(self.win_length).to(Y.device)).to(dtype=x.dtype)
-
-class StreamedTorchGate(SpectralGate):
-    def __init__(self, y, sr, stationary=False, y_noise=None, prop_decrease=1.0, time_constant_s=2.0, freq_mask_smooth_hz=500, time_mask_smooth_ms=50, thresh_n_mult_nonstationary=2, sigmoid_slope_nonstationary=10, n_std_thresh_stationary=1.5, tmp_folder=None, chunk_size=600000, padding=30000, n_fft=1024, win_length=None, hop_length=None, clip_noise_stationary=True, use_tqdm=False, n_jobs=1, device="cpu"):
-        super().__init__(y=y, sr=sr, chunk_size=chunk_size, padding=padding, n_fft=n_fft, win_length=win_length, hop_length=hop_length, time_constant_s=time_constant_s, freq_mask_smooth_hz=freq_mask_smooth_hz, time_mask_smooth_ms=time_mask_smooth_ms, tmp_folder=tmp_folder, prop_decrease=prop_decrease, use_tqdm=use_tqdm, n_jobs=n_jobs)
-        self.device = torch.device(device if torch.cuda.is_available() else 'cpu')
-
-        if y_noise is not None:
-            if y_noise.shape[-1] > y.shape[-1] and clip_noise_stationary: y_noise = y_noise[: y.shape[-1]]
-            y_noise = torch.from_numpy(y_noise).to(device)
-            if len(y_noise.shape) == 1: y_noise = y_noise.unsqueeze(0)
-
-        self.y_noise = y_noise
-        self.tg = TG(sr=sr, nonstationary=not stationary, n_std_thresh_stationary=n_std_thresh_stationary, n_thresh_nonstationary=thresh_n_mult_nonstationary, temp_coeff_nonstationary=1 / sigmoid_slope_nonstationary, n_movemean_nonstationary=int(time_constant_s / self._hop_length * sr), prop_decrease=prop_decrease, n_fft=self._n_fft, win_length=self._win_length, hop_length=self._hop_length, freq_mask_smooth_hz=freq_mask_smooth_hz, time_mask_smooth_ms=time_mask_smooth_ms).to(device)
-
-    def _do_filter(self, chunk):
-        if type(chunk) is np.ndarray: chunk = torch.from_numpy(chunk).to(self.device)
-        return self.tg(x=chunk, xn=self.y_noise).cpu().detach().numpy()
 
-def reduce_noise(y, sr, stationary=False, y_noise=None, prop_decrease=1.0, time_constant_s=2.0, freq_mask_smooth_hz=500, time_mask_smooth_ms=50, thresh_n_mult_nonstationary=2, sigmoid_slope_nonstationary=10, tmp_folder=None, chunk_size=600000, padding=30000, n_fft=1024, win_length=None, hop_length=None, clip_noise_stationary=True, use_tqdm=False, device="cpu"):
-    return StreamedTorchGate(y=y, sr=sr, stationary=stationary, y_noise=y_noise, prop_decrease=prop_decrease, time_constant_s=time_constant_s, freq_mask_smooth_hz=freq_mask_smooth_hz, time_mask_smooth_ms=time_mask_smooth_ms, thresh_n_mult_nonstationary=thresh_n_mult_nonstationary, sigmoid_slope_nonstationary=sigmoid_slope_nonstationary, tmp_folder=tmp_folder, chunk_size=chunk_size, padding=padding, n_fft=n_fft, win_length=win_length, hop_length=hop_length, clip_noise_stationary=clip_noise_stationary, use_tqdm=use_tqdm, n_jobs=1, device=device).get_traces()
+        return (
+            self.stft.inverse(
+                Y, 
+                phase
+            )
+        ) if hasattr(self, "stft") else (
+            torch.istft(
+                Y, 
+                n_fft=self.n_fft, 
+                hop_length=self.hop_length, 
+                win_length=self.win_length, 
+                center=True, 
+                window=torch.hann_window(self.win_length).to(Y.device)
+            ).to(dtype=x.dtype)
+        )

tools/utils/pixeldrain.py

@@ -0,0 +1,21 @@
+import os
+import requests
+
+def pixeldrain(url, output_dir):
+    try:
+        response = requests.get(f"https://pixeldrain.com/api/file/{url.split('pixeldrain.com/u/')[1]}")
+
+        if response.status_code == 200:
+            file_path = os.path.join(
+                output_dir, 
+                response.headers.get("Content-Disposition").split("filename=")[-1].strip('";')
+            )
+
+            with open(file_path, "wb") as newfile:
+                newfile.write(response.content)
+
+            return file_path
+
+        return None
+    except Exception as e:
+        raise RuntimeError(e)