Format code (#1193)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

configs/config.py

@@ -5,10 +5,13 @@
 from multiprocessing import cpu_count
 
 import torch
+
 try:
-    import intel_extension_for_pytorch as ipex # pylint: disable=import-error, unused-import
+    import intel_extension_for_pytorch as ipex  # pylint: disable=import-error, unused-import
+
     if torch.xpu.is_available():
         from infer.modules.ipex import ipex_init
+
         ipex_init()
 except Exception:
     pass

gui_v1.py

@@ -478,15 +478,28 @@ def start_vc(self):
                 inp_q,
                 opt_q,
                 device,
-                self.rvc if hasattr(self, "rvc") else None
+                self.rvc if hasattr(self, "rvc") else None,
             )
             self.config.samplerate = self.rvc.tgt_sr
             self.zc = self.rvc.tgt_sr // 100
-            self.block_frame = int(np.round(self.config.block_time * self.config.samplerate / self.zc)) * self.zc
+            self.block_frame = (
+                int(np.round(self.config.block_time * self.config.samplerate / self.zc))
+                * self.zc
+            )
             self.block_frame_16k = 160 * self.block_frame // self.zc
-            self.crossfade_frame = int(np.round(self.config.crossfade_time * self.config.samplerate / self.zc)) * self.zc
+            self.crossfade_frame = (
+                int(
+                    np.round(
+                        self.config.crossfade_time * self.config.samplerate / self.zc
+                    )
+                )
+                * self.zc
+            )
             self.sola_search_frame = self.zc
-            self.extra_frame = int(np.round(self.config.extra_time * self.config.samplerate / self.zc)) * self.zc
+            self.extra_frame = (
+                int(np.round(self.config.extra_time * self.config.samplerate / self.zc))
+                * self.zc
+            )
             self.input_wav: torch.Tensor = torch.zeros(
                 self.extra_frame
                 + self.crossfade_frame
@@ -495,7 +508,11 @@ def start_vc(self):
                 device=device,
                 dtype=torch.float32,
             )
-            self.input_wav_res: torch.Tensor= torch.zeros(160 * self.input_wav.shape[0] // self.zc, device=device,dtype=torch.float32)
+            self.input_wav_res: torch.Tensor = torch.zeros(
+                160 * self.input_wav.shape[0] // self.zc,
+                device=device,
+                dtype=torch.float32,
+            )
             self.pitch: np.ndarray = np.zeros(
                 self.input_wav.shape[0] // self.zc,
                 dtype="int32",
@@ -509,7 +526,9 @@ def start_vc(self):
             )
             self.nr_buffer: torch.Tensor = self.sola_buffer.clone()
             self.output_buffer: torch.Tensor = self.input_wav.clone()
-            self.res_buffer: torch.Tensor = torch.zeros(2 * self.zc, device=device,dtype=torch.float32)
+            self.res_buffer: torch.Tensor = torch.zeros(
+                2 * self.zc, device=device, dtype=torch.float32
+            )
             self.valid_rate = 1 - (self.extra_frame - 1) / self.input_wav.shape[0]
             self.fade_in_window: torch.Tensor = (
                 torch.sin(
@@ -529,7 +548,9 @@ def start_vc(self):
             self.resampler = tat.Resample(
                 orig_freq=self.config.samplerate, new_freq=16000, dtype=torch.float32
             ).to(device)
-            self.tg = TorchGate(sr=self.config.samplerate, n_fft=4*self.zc, prop_decrease=0.9).to(device)
+            self.tg = TorchGate(
+                sr=self.config.samplerate, n_fft=4 * self.zc, prop_decrease=0.9
+            ).to(device)
             thread_vc = threading.Thread(target=self.soundinput)
             thread_vc.start()
 
@@ -560,36 +581,52 @@ def audio_callback(
             indata = librosa.to_mono(indata.T)
             if self.config.threhold > -60:
                 rms = librosa.feature.rms(
-                y=indata, frame_length=4*self.zc, hop_length=self.zc
+                    y=indata, frame_length=4 * self.zc, hop_length=self.zc
                 )
                 db_threhold = (
                     librosa.amplitude_to_db(rms, ref=1.0)[0] < self.config.threhold
                 )
                 for i in range(db_threhold.shape[0]):
                     if db_threhold[i]:
                         indata[i * self.zc : (i + 1) * self.zc] = 0
-            self.input_wav[: -self.block_frame] = self.input_wav[self.block_frame :].clone()
-            self.input_wav[-self.block_frame: ] = torch.from_numpy(indata).to(device)
-            self.input_wav_res[ : -self.block_frame_16k] = self.input_wav_res[self.block_frame_16k :].clone()
+            self.input_wav[: -self.block_frame] = self.input_wav[
+                self.block_frame :
+            ].clone()
+            self.input_wav[-self.block_frame :] = torch.from_numpy(indata).to(device)
+            self.input_wav_res[: -self.block_frame_16k] = self.input_wav_res[
+                self.block_frame_16k :
+            ].clone()
             # input noise reduction and resampling
             if self.config.I_noise_reduce:
-                input_wav = self.input_wav[-self.crossfade_frame -self.block_frame-2*self.zc: ]
-                input_wav = self.tg(input_wav.unsqueeze(0), self.input_wav.unsqueeze(0))[0, 2*self.zc:]
+                input_wav = self.input_wav[
+                    -self.crossfade_frame - self.block_frame - 2 * self.zc :
+                ]
+                input_wav = self.tg(
+                    input_wav.unsqueeze(0), self.input_wav.unsqueeze(0)
+                )[0, 2 * self.zc :]
                 input_wav[: self.crossfade_frame] *= self.fade_in_window
-                input_wav[: self.crossfade_frame] += self.nr_buffer * self.fade_out_window
-                self.nr_buffer[:] = input_wav[-self.crossfade_frame: ]
-                input_wav = torch.cat((self.res_buffer[:], input_wav[: self.block_frame]))
-                self.res_buffer[:] = input_wav[-2*self.zc: ]
-                self.input_wav_res[-self.block_frame_16k-160: ] = self.resampler(input_wav)[160: ]
+                input_wav[: self.crossfade_frame] += (
+                    self.nr_buffer * self.fade_out_window
+                )
+                self.nr_buffer[:] = input_wav[-self.crossfade_frame :]
+                input_wav = torch.cat(
+                    (self.res_buffer[:], input_wav[: self.block_frame])
+                )
+                self.res_buffer[:] = input_wav[-2 * self.zc :]
+                self.input_wav_res[-self.block_frame_16k - 160 :] = self.resampler(
+                    input_wav
+                )[160:]
             else:
-                self.input_wav_res[-self.block_frame_16k-160: ] = self.resampler(self.input_wav[-self.block_frame-2*self.zc: ])[160: ]
+                self.input_wav_res[-self.block_frame_16k - 160 :] = self.resampler(
+                    self.input_wav[-self.block_frame - 2 * self.zc :]
+                )[160:]
             # infer
             f0_extractor_frame = self.block_frame_16k + 800
-            if self.config.f0method == 'rmvpe':
+            if self.config.f0method == "rmvpe":
                 f0_extractor_frame = 5120 * ((f0_extractor_frame - 1) // 5120 + 1)
             infer_wav = self.rvc.infer(
                 self.input_wav_res,
-                self.input_wav_res[-f0_extractor_frame :].cpu().numpy(),
+                self.input_wav_res[-f0_extractor_frame:].cpu().numpy(),
                 self.block_frame_16k,
                 self.valid_rate,
                 self.pitch,
@@ -601,48 +638,77 @@ def audio_callback(
             ]
             # output noise reduction
             if self.config.O_noise_reduce:
-                self.output_buffer[: -self.block_frame] = self.output_buffer[self.block_frame :].clone()
-                self.output_buffer[-self.block_frame: ] = infer_wav[-self.block_frame:]
-                infer_wav = self.tg(infer_wav.unsqueeze(0), self.output_buffer.unsqueeze(0)).squeeze(0)
+                self.output_buffer[: -self.block_frame] = self.output_buffer[
+                    self.block_frame :
+                ].clone()
+                self.output_buffer[-self.block_frame :] = infer_wav[-self.block_frame :]
+                infer_wav = self.tg(
+                    infer_wav.unsqueeze(0), self.output_buffer.unsqueeze(0)
+                ).squeeze(0)
             # volume envelop mixing
             if self.config.rms_mix_rate < 1:
                 rms1 = librosa.feature.rms(
-                y=self.input_wav_res[-160*infer_wav.shape[0]//self.zc :].cpu().numpy(), 
-                frame_length=640, 
-                hop_length=160,
+                    y=self.input_wav_res[-160 * infer_wav.shape[0] // self.zc :]
+                    .cpu()
+                    .numpy(),
+                    frame_length=640,
+                    hop_length=160,
                 )
                 rms1 = torch.from_numpy(rms1).to(device)
                 rms1 = F.interpolate(
-                    rms1.unsqueeze(0), size=infer_wav.shape[0] + 1, mode="linear",align_corners=True,
-                )[0,0,:-1]
+                    rms1.unsqueeze(0),
+                    size=infer_wav.shape[0] + 1,
+                    mode="linear",
+                    align_corners=True,
+                )[0, 0, :-1]
                 rms2 = librosa.feature.rms(
-                y=infer_wav[:].cpu().numpy(), frame_length=4*self.zc, hop_length=self.zc
+                    y=infer_wav[:].cpu().numpy(),
+                    frame_length=4 * self.zc,
+                    hop_length=self.zc,
                 )
                 rms2 = torch.from_numpy(rms2).to(device)
                 rms2 = F.interpolate(
-                    rms2.unsqueeze(0), size=infer_wav.shape[0] + 1, mode="linear",align_corners=True,
-                )[0,0,:-1]
+                    rms2.unsqueeze(0),
+                    size=infer_wav.shape[0] + 1,
+                    mode="linear",
+                    align_corners=True,
+                )[0, 0, :-1]
                 rms2 = torch.max(rms2, torch.zeros_like(rms2) + 1e-3)
-                infer_wav *= torch.pow(rms1 / rms2, torch.tensor(1 - self.config.rms_mix_rate))
+                infer_wav *= torch.pow(
+                    rms1 / rms2, torch.tensor(1 - self.config.rms_mix_rate)
+                )
             # SOLA algorithm from https://github.com/yxlllc/DDSP-SVC
-            conv_input = infer_wav[None, None, : self.crossfade_frame + self.sola_search_frame]
+            conv_input = infer_wav[
+                None, None, : self.crossfade_frame + self.sola_search_frame
+            ]
             cor_nom = F.conv1d(conv_input, self.sola_buffer[None, None, :])
             cor_den = torch.sqrt(
-                F.conv1d(conv_input ** 2, torch.ones(1, 1, self.crossfade_frame, device=device)) + 1e-8)
+                F.conv1d(
+                    conv_input**2,
+                    torch.ones(1, 1, self.crossfade_frame, device=device),
+                )
+                + 1e-8
+            )
             if sys.platform == "darwin":
                 _, sola_offset = torch.max(cor_nom[0, 0] / cor_den[0, 0])
                 sola_offset = sola_offset.item()
             else:
                 sola_offset = torch.argmax(cor_nom[0, 0] / cor_den[0, 0])
             logger.debug("sola_offset = %d", int(sola_offset))
-            infer_wav = infer_wav[sola_offset: sola_offset + self.block_frame + self.crossfade_frame]
+            infer_wav = infer_wav[
+                sola_offset : sola_offset + self.block_frame + self.crossfade_frame
+            ]
             infer_wav[: self.crossfade_frame] *= self.fade_in_window
-            infer_wav[: self.crossfade_frame] += self.sola_buffer *self.fade_out_window
-            self.sola_buffer[:] = infer_wav[-self.crossfade_frame:]
+            infer_wav[: self.crossfade_frame] += self.sola_buffer * self.fade_out_window
+            self.sola_buffer[:] = infer_wav[-self.crossfade_frame :]
             if sys.platform == "darwin":
-                outdata[:] = infer_wav[:-self.crossfade_frame].cpu().numpy()[:, np.newaxis]
+                outdata[:] = (
+                    infer_wav[: -self.crossfade_frame].cpu().numpy()[:, np.newaxis]
+                )
             else:
-                outdata[:] = infer_wav[:-self.crossfade_frame].repeat(2, 1).t().cpu().numpy()
+                outdata[:] = (
+                    infer_wav[: -self.crossfade_frame].repeat(2, 1).t().cpu().numpy()
+                )
             total_time = time.perf_counter() - start_time
             self.window["infer_time"].update(int(total_time * 1000))
             logger.info("Infer time: %.2f", total_time)
@@ -698,9 +764,7 @@ def set_devices(self, input_device, output_device):
             sd.default.device[1] = output_device_indices[
                 output_devices.index(output_device)
             ]
-            logger.info(
-                "Input device: %s:%s", str(sd.default.device[0]), input_device
-            )
+            logger.info("Input device: %s:%s", str(sd.default.device[0]), input_device)
             logger.info(
                 "Output device: %s:%s", str(sd.default.device[1]), output_device
             )

infer-web.py

@@ -1028,7 +1028,7 @@ def change_f0_method(f0method8):
                 fn=vc.get_vc,
                 inputs=[sid0, protect0, protect1],
                 outputs=[spk_item, protect0, protect1, file_index2, file_index4],
-                api_name="infer_change_voice"
+                api_name="infer_change_voice",
             )
         with gr.TabItem(i18n("伴奏人声分离&去混响&去回声")):
             with gr.Group():

infer/lib/audio.py

@@ -3,38 +3,49 @@
 import av
 from io import BytesIO
 
+
 def wav2(i, o, format):
-    inp = av.open(i, 'rb')
-    if format == "m4a": format = "mp4"
-    out = av.open(o, 'wb', format=format)
-    if format == "ogg": format = "libvorbis"
-    if format == "mp4": format = "aac"
+    inp = av.open(i, "rb")
+    if format == "m4a":
+        format = "mp4"
+    out = av.open(o, "wb", format=format)
+    if format == "ogg":
+        format = "libvorbis"
+    if format == "mp4":
+        format = "aac"
 
     ostream = out.add_stream(format)
 
     for frame in inp.decode(audio=0):
-        for p in ostream.encode(frame): out.mux(p)
+        for p in ostream.encode(frame):
+            out.mux(p)
 
-    for p in ostream.encode(None): out.mux(p)
+    for p in ostream.encode(None):
+        out.mux(p)
 
     out.close()
     inp.close()
 
+
 def audio2(i, o, format, sr):
-    inp = av.open(i, 'rb')
-    out = av.open(o, 'wb', format=format)
-    if format == "ogg": format = "libvorbis"
-    if format == "f32le": format = "pcm_f32le"
+    inp = av.open(i, "rb")
+    out = av.open(o, "wb", format=format)
+    if format == "ogg":
+        format = "libvorbis"
+    if format == "f32le":
+        format = "pcm_f32le"
 
     ostream = out.add_stream(format, channels=1)
     ostream.sample_rate = sr
 
     for frame in inp.decode(audio=0):
-        for p in ostream.encode(frame): out.mux(p)
+        for p in ostream.encode(frame):
+            out.mux(p)
 
     out.close()
     inp.close()
 
+
 def load_audio(file, sr):
     try:
         file = (

infer/lib/infer_pack/models.py

@@ -15,6 +15,7 @@
 
 has_xpu = bool(hasattr(torch, "xpu") and torch.xpu.is_available())
 
+
 class TextEncoder256(nn.Module):
     def __init__(
         self,
@@ -1158,7 +1159,9 @@ def forward(self, x):
         if t % self.period != 0:  # pad first
             n_pad = self.period - (t % self.period)
             if has_xpu and x.dtype == torch.bfloat16:
-                x = F.pad(x.to(dtype=torch.float16), (0, n_pad), "reflect").to(dtype=torch.bfloat16)
+                x = F.pad(x.to(dtype=torch.float16), (0, n_pad), "reflect").to(
+                    dtype=torch.bfloat16
+                )
             else:
                 x = F.pad(x, (0, n_pad), "reflect")
             t = t + n_pad

infer/lib/rmvpe.py

@@ -2,11 +2,14 @@
 
 import numpy as np
 import torch
+
 try:
-    #Fix "Torch not compiled with CUDA enabled"
-    import intel_extension_for_pytorch as ipex # pylint: disable=import-error, unused-import
+    # Fix "Torch not compiled with CUDA enabled"
+    import intel_extension_for_pytorch as ipex  # pylint: disable=import-error, unused-import
+
     if torch.xpu.is_available():
         from infer.modules.ipex import ipex_init
+
         ipex_init()
 except Exception:
     pass