Upload folder using huggingface_hub

app.py

@@ -248,7 +248,7 @@ def process_single(target_text_list, prompt_wav_list, prompt_text_list, use_dial
         text, spk = match.group(2), int(match.group(1)[2])-1
         spks.append(spk)
         texts.append(text)
-    
+    import pdb;pdb.set_trace()
     global dataset
     dataitem = {"key": "001", "prompt_text": prompt_text_list, "prompt_wav": prompt_wav_list, 
              "text": texts, "spk": spks, }

soulxpodcast/config.py

@@ -8,6 +8,7 @@ import torch
 from transformers import AutoConfig
 from transformers import PretrainedConfig
 
+
 @dataclass
 class SoulXPodcastLLMConfig:
     architectures: list[str] = field(default_factory=lambda: ["Qwen3ForCausalLM"])
@@ -47,11 +48,11 @@ class SoulXPodcastLLMConfig:
         json_file: Optional[str] = None
     ):
         """
-        Create instance from initial values and JSON data
+        Create an instance from initial values and JSON data.
 
         Args:
-            initial_values: Initial key-value dict, which will overrides all other configurations
-            json_file: JSON file path
+            initial_values: Dictionary of initial values (highest priority)
+            json_file: Path to JSON file
 
         Returns:
             SoulXPodcastLLMConfig instance
@@ -76,7 +77,7 @@ class SoulXPodcastLLMConfig:
 
     @staticmethod
     def _load_json_file(file_path: str) -> Dict[str, Any]:
-        """从JSON文件加载数据"""
+        """Load data from a JSON file"""
         path = Path(file_path)
         if not path.exists():
             return {}
@@ -94,7 +95,7 @@ class AutoPretrainedConfig(PretrainedConfig):
 
     @classmethod
     def from_dataclass(cls, dataclass_config):
-        """Dynamically generate config from dataclass"""
+        """Automatically create configuration from any dataclass"""
         if not is_dataclass(dataclass_config):
             raise ValueError("Input must be a dataclass instance")
 
@@ -108,8 +109,8 @@ class SamplingParams:
     repetition_penalty: float = 1.25
     top_k: int = 100
     top_p: float = 0.9
-    max_tokens: int = 3000
     min_tokens: int = 8
+    max_tokens: int = 3000
     stop_token_ids: list[int] = field(default_factory=lambda: [151675])
 
     use_ras: bool = True
@@ -127,12 +128,12 @@ class Config:
     hf_config: SoulXPodcastLLMConfig | AutoConfig = field(default_factory=SoulXPodcastLLMConfig)
     eos: int = -1
     llm_engine: str = "hf"
-    max_turn_size: int = 14
+    max_turn_size: int = 10
     turn_tokens_threshold: int = 6192
 
     prompt_context: int = 2
-    history_context: int = 4
-    history_text_context: int = 4
+    history_context: int = 2
+    history_text_context: int = 2
 
     def __post_init__(self):
         assert os.path.isdir(self.model)

soulxpodcast/engine/llm_engine.py

@@ -1,9 +1,9 @@
+import os
 import types
 import atexit
-from dataclasses import fields, asdict
 from time import perf_counter
-import os
 from functools import partial
+from dataclasses import fields, asdict
 
 import torch
 import torch.multiprocessing as mp
@@ -17,8 +17,8 @@ try:
 except ImportError:
     SUPPORT_VLLM = False
 
-from soulxpodcast.models.modules.sampler import _ras_sample_hf_engine
 from soulxpodcast.config import Config, SamplingParams
+from soulxpodcast.models.modules.sampler import _ras_sample_hf_engine
 
 class HFLLMEngine:
 
@@ -41,7 +41,6 @@ class HFLLMEngine:
         past_key_values=None,
     ) -> dict:
 
-
         stopping_criteria = StoppingCriteriaList([EosTokenCriteria(eos_token_id=self.config.hf_config.eos_token_id)])
         if sampling_param.use_ras:
             sample_hf_engine_handler = partial(_ras_sample_hf_engine,
@@ -63,7 +62,6 @@ class HFLLMEngine:
                 min_new_tokens=sampling_param.min_tokens,
                 max_new_tokens=sampling_param.max_tokens,
                 temperature=sampling_param.temperature,
-                repetition_penalty=sampling_param.repetition_penalty,
                 stopping_criteria=stopping_criteria,
                 past_key_values=past_key_values,
                 custom_generate=sample_hf_engine_handler,
@@ -90,7 +88,7 @@ class VLLMEngine:
         self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
         os.environ["VLLM_USE_V1"] = "0"
         if SUPPORT_VLLM:
-            self.model = LLM(model=model, enforce_eager=True, dtype="bfloat16", max_model_len=8192, enable_prefix_caching=True)
+            self.model = LLM(model=model, enforce_eager=True, dtype="bfloat16", max_model_len=8192)
         else:
             raise ImportError("Not Support VLLM now!!!")
         self.config = config

soulxpodcast/models/modules/flow_components/upsample_encoder.py

@@ -493,8 +493,7 @@ class MultiHeadedAttention(nn.Module):
                 the mask is in (#batch, L, L)  shape.
                 4.If the different position in decoder see different block
                 of the encoder, such as Mocha, the passed in mask could be
-                in (#batch, L, T) shape. But there is no such case in current
-                CosyVoice.
+                in (#batch, L, T) shape.
             cache (torch.Tensor): Cache tensor (1, head, cache_t, d_k * 2),
                 where `cache_t == chunk_size * num_decoding_left_chunks`
                 and `head * d_k == size`

soulxpodcast/models/modules/hifigan.py

@@ -231,7 +231,7 @@ class HiFTGenerator(nn.Module):
         phase = torch.sin(x[:, self.istft_params["n_fft"] // 2 + 1:, :])
 
         x = self._istft(magnitude, phase)
-        x = torch.clamp(x*0.98, -self.audio_limit, self.audio_limit)
+        x = torch.clamp(x, -self.audio_limit, self.audio_limit)
         return x
 
     @torch.inference_mode()

soulxpodcast/models/soulxpodcast.py

@@ -1,7 +1,8 @@
 import time
 from datetime import datetime
-from itertools import chain
+
 from tqdm import tqdm
+from itertools import chain
 from copy import deepcopy
 
 import numpy as np
@@ -55,11 +56,12 @@ class SoulXPodcast(torch.nn.Module):
         spk_emb_for_flow: torch.Tensor,
         sampling_params: SamplingParams | list[SamplingParams],
         spk_ids: list[list[int]],
-        use_prompt_cot: bool = False,
-        prompt_cot_text_tokens_for_llm: list[list[int]] = None,
-        prompt_cot_prefix: list[list[int]] = None,
+        use_dialect_prompt: bool = False,
+        dialect_prompt_text_tokens_for_llm: list[list[int]] = None,
+        dialect_prefix: list[list[int]] = None,
         **kwargs,
     ):
+
         prompt_size, turn_size = len(prompt_mels_for_llm), len(text_tokens_for_llm)
 
 
@@ -91,37 +93,16 @@ class SoulXPodcast(torch.nn.Module):
         prompt_inputs = []
         history_inputs = []
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
         for i in range(prompt_size):
             speech_tokens_i = [token+self.config.hf_config.speech_token_offset for token in prompt_speech_tokens[i].tolist()]
             speech_tokens_i += [self.config.hf_config.eos_token_id]
-            if use_prompt_cot and len(prompt_cot_text_tokens_for_llm[i])>0:
-                prompt_cot_input = prompt_text_tokens_for_llm[i] + speech_tokens_i + prompt_cot_text_tokens_for_llm[i]
+            if use_dialect_prompt and len(dialect_prompt_text_tokens_for_llm[i])>0:
+                dialect_prompt_input = prompt_text_tokens_for_llm[i] + speech_tokens_i + dialect_prompt_text_tokens_for_llm[i]
                 if i>0:
-                    prompt_cot_input = prompt_cot_prefix[0] + prompt_cot_input
-                cot_input = self.llm.generate(prompt_cot_input, sampling_params, past_key_values=None)['token_ids']
-                prompt_inputs.append(prompt_cot_prefix[i+1]+prompt_cot_text_tokens_for_llm[i] + cot_input)
-                history_inputs.append(prompt_cot_prefix[i+1]+prompt_cot_text_tokens_for_llm[i] + cot_input)
+                    dialect_prompt_input = dialect_prefix[0] + dialect_prompt_input
+                prompt_input = self.llm.generate(dialect_prompt_input, sampling_params, past_key_values=None)['token_ids']
+                prompt_inputs.append(dialect_prefix[i+1]+dialect_prompt_text_tokens_for_llm[i] + prompt_input)
+                history_inputs.append(dialect_prefix[i+1]+dialect_prompt_text_tokens_for_llm[i] + prompt_input)
             else:
                 prompt_inputs.append(prompt_text_tokens_for_llm[i] + speech_tokens_i )
                 history_inputs.append(prompt_text_tokens_for_llm[i] + speech_tokens_i )
@@ -164,7 +145,6 @@ class SoulXPodcast(torch.nn.Module):
             flow_inputs_len = torch.tensor([len(prompt_speech_token) + len(generated_speech_tokens)])
 
 
-
             start_idx = spk_ids[i]
             prompt_mels = prompt_mels_for_flow[start_idx][None]
             prompt_mels_lens = prompt_mels_lens_for_flow[start_idx][None]
@@ -180,11 +160,7 @@ class SoulXPodcast(torch.nn.Module):
 
 
             mel = generated_mels[:, :, prompt_mels_lens[0].item():generated_mels_lens[0].item()]
-            try:
-                wav, _ = self.hift(speech_feat=mel)
-            except Exception as e:
-                import pdb;pdb.set_trace()
-                print(e)
+            wav, _ = self.hift(speech_feat=mel)
             generated_wavs.append(wav)
 
 

soulxpodcast/utils/audio.py

@@ -1,5 +1,5 @@
-import numpy as np
 import torch
+import numpy as np
 from librosa.filters import mel as librosa_mel_fn
 from scipy.io.wavfile import read
 
@@ -75,3 +75,49 @@ def mel_spectrogram(y, n_fft=1920, num_mels=80, sampling_rate=24000, hop_size=48
     spec = spectral_normalize_torch(spec)
 
     return spec
+
+
+def audio_volume_normalize(audio: torch.Tensor, coeff=0.1):
+    """
+    Normalize the volume of an audio signal.
+
+    Parameters:
+        audio (torch tensor): Input audio signal array.
+        coeff (float): Target coefficient for normalization, default is 0.1.
+
+    Returns:
+        torch tensor: The volume-normalized audio signal.
+    """
+
+    device = audio.device
+    audio = audio.cpu().numpy()
+    temp = np.sort(np.abs(audio))
+
+
+    if temp[-1] < 0.1:
+        scaling_factor = max(
+            temp[-1], 1e-3
+        )
+        audio = audio / scaling_factor * 0.1
+
+
+    temp = temp[temp > 0.01]
+    L = temp.shape[0]
+
+
+    if L <= 10:
+        return audio
+
+
+    volume = np.mean(temp[int(0.9 * L) : int(0.99 * L)])
+
+
+    audio = audio * np.clip(coeff / volume, a_min=0.1, a_max=10)
+
+
+    max_value = np.max(np.abs(audio))
+    if max_value > 1:
+        audio = audio / max_value
+
+    audio = torch.from_numpy(audio).to(device)
+    return audio

soulxpodcast/utils/commons.py

@@ -0,0 +1,10 @@
+import random
+import numpy as np
+import torch
+
+
+def set_all_random_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)

soulxpodcast/utils/dataloader.py

@@ -11,8 +11,8 @@ import torchaudio.compliance.kaldi as kaldi
 
 import s3tokenizer
 
-from soulxpodcast.utils.audio import mel_spectrogram
 from soulxpodcast.utils.text import normalize_text
+from soulxpodcast.utils.audio import mel_spectrogram, audio_volume_normalize
 from soulxpodcast.config import Config, SamplingParams
 
 
@@ -29,13 +29,13 @@ class PodcastDataset(Dataset):
 
         """Example data_list:
         ```
-        {"key": "uttid_1", "prompt_text": ["prompt_text1", "prompt_text2"], "prompt_cot_text": ["prompt_cot_text1", "prompt_cot_text2"],
+        {"key": "uttid_1", "prompt_text": ["prompt_text1", "prompt_text2"], "dialect_prompt_text": ["dialect_prompt_text1", "dialect_prompt_text2"],
             "text": ["text1", "text2], "spk": [0, 1], "prompt_wav": ["/mnt/data/audio/00000000.wav", "/mnt/data/audio/00000001.wav"], "wav": "/mnt/data/audio_synthetic/uttid_1.wav"}
         ```
         Note:
             - `key` is the key of this sample.
             - `prompt_text` is the text used for prompt.
-            - `prompt_cot_text` is the reshot text used for prompt.
+            - `dialect_prompt_text` is the reshot text used for prompt.
             - `text` is the text used for generating real audio.
             - `spk` is the target speaker id to synthesize, corresponds to the prompt order. Default SPEAKER_0.
             - `prompt_wav` is the audio used for prompt.
@@ -82,16 +82,18 @@ class PodcastDataset(Dataset):
     def __getitem__(self, idx):
         data = self.datas[idx]
         try:
-            prompt_text_ids_list, prompt_cot_text_ids_list, spk_emb_list, mel_list, mel_len_list, log_mel_list = (
+            prompt_text_ids_list, dialect_prompt_text_ids_list, spk_emb_list, mel_list, mel_len_list, log_mel_list = (
                 [], [], [], [], [], []
             )
 
-            use_prompt_cot = "prompt_cot_text" in data
-            prompt_cot_prefix_list = []
-            prompt_cot_prefix_list.append(self.text_tokenizer.encode(f"{TASK_PODCAST}"))
+            use_dialect_prompt = "dialect_prompt_text" in data
+            dialect_prefix_list = []
+            dialect_prefix_list.append(self.text_tokenizer.encode(f"{TASK_PODCAST}"))
             for spk_idx, (prompt_text, prompt_wav) in enumerate(zip(data["prompt_text"], data["prompt_wav"])):
 
                 audio = s3tokenizer.load_audio(prompt_wav, sr=16000)
+                audio = audio_volume_normalize(audio)
+
                 log_mel = s3tokenizer.log_mel_spectrogram(audio)
 
 
@@ -103,7 +105,9 @@ class PodcastDataset(Dataset):
 
 
                 audio, sample_rate = torchaudio.load(prompt_wav, backend='soundfile')
-                audio = audio.mean(dim=0, keepdim=True)
+                audio = audio[0]
+                audio = audio_volume_normalize(audio).unsqueeze(0)
+
                 if sample_rate != 24000:
                     audio = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=24000)(audio)
                 mel = mel_spectrogram(audio).transpose(1, 2).squeeze(0)
@@ -118,15 +122,19 @@ class PodcastDataset(Dataset):
                     prompt_text = f"{TASK_PODCAST}{prompt_text}"
                 prompt_text_ids = self.text_tokenizer.encode(prompt_text)
                 prompt_text_ids_list.append(prompt_text_ids)
-                if use_prompt_cot:
-                    prompt_cot_text = normalize_text(data["prompt_cot_text"][spk_idx])
-                    prompt_cot_text = f"{SPK_DICT[spk_idx]}{TEXT_START}{prompt_cot_text}{TEXT_END}{AUDIO_START}"
-                    prompt_cot_text_ids = self.text_tokenizer.encode(prompt_cot_text)
-                    prompt_cot_text_ids_list.append(prompt_cot_text_ids)
+                if use_dialect_prompt:
+                    
+                    dialect_prompt_text = normalize_text(data["dialect_prompt_text"][spk_idx])
+                    dialect_prompt_text = f"{SPK_DICT[spk_idx]}{TEXT_START}{dialect_prompt_text}{TEXT_END}{AUDIO_START}"
+                    dialect_prompt_text_ids = self.text_tokenizer.encode(dialect_prompt_text)
+                    # import pdb; pdb.set_trace()
+                    print(f"dialect_prompt_text_ids: {dialect_prompt_text_ids}")
+                    print(f"dialect_prompt_text: {dialect_prompt_text}")
+                    dialect_prompt_text_ids_list.append(dialect_prompt_text_ids)
                     if spk_idx == 0:
-                        prompt_cot_prefix_list.append(self.text_tokenizer.encode(f"{TASK_PODCAST}"))
+                        dialect_prefix_list.append(self.text_tokenizer.encode(f"{TASK_PODCAST}"))
                     else:
-                        prompt_cot_prefix_list.append([])
+                        dialect_prefix_list.append([])
                 log_mel_list.append(log_mel)
                 spk_emb_list.append(spk_emb)
                 mel_list.append(mel); mel_len_list.append(mel_len)
@@ -134,11 +142,14 @@ class PodcastDataset(Dataset):
                 "prompt_text_tokens": prompt_text_ids_list,
                 "spk_emb": spk_emb_list, "mel": mel_list, "mel_len": mel_len_list, "log_mel": log_mel_list, "info": data,
             }
-            if use_prompt_cot:
+            if use_dialect_prompt:
+                import pdb; pdb.set_trace()
+                print(f"dialect_prompt_text_ids: {dialect_prompt_text_ids}")
+                print(f"dialect_prompt_text: {dialect_prompt_text}")
                 item.update({
-                    "use_prompt_cot": True,
-                    "prompt_cot_text_tokens": prompt_cot_text_ids_list,
-                    "prompt_cot_prefix": prompt_cot_prefix_list,
+                    "use_dialect_prompt": True,
+                    "dialect_prompt_text_tokens": dialect_prompt_text_ids_list,
+                    "dialect_prefix": dialect_prefix_list,
                 })
             text_ids_list, spks_list = [], []
             if "spk" not in data:
@@ -170,12 +181,12 @@ class PodcastInferHandler(PodcastDataset):
 
         """Example data_list:
         ```
-        {"key": "uttid_1", "prompt_text": ["prompt_text1", "prompt_text2"], "prompt_cot_text": ["prompt_cot_text1", "prompt_cot_text2"], "text": ["text1", "text2], "spk": [0, 1], "prompt_wav": ["/mnt/data/audio/00000000.wav", "/mnt/data/audio/00000001.wav"], "wav": "/mnt/data/audio_synthetic/uttid_1.wav"}
+        {"key": "uttid_1", "prompt_text": ["prompt_text1", "prompt_text2"], "dialect_prompt_text": ["dialect_prompt_text1", "dialect_prompt_text2"], "text": ["text1", "text2], "spk": [0, 1], "prompt_wav": ["/mnt/data/audio/00000000.wav", "/mnt/data/audio/00000001.wav"], "wav": "/mnt/data/audio_synthetic/uttid_1.wav"}
         ```
         Note:
             - `key` is the key of this sample.
             - `prompt_text` is the text used for prompt.
-            - `prompt_cot_text` is the cot text used for prompt as to activate specific ability.
+            - `dialect_prompt_text` is the cot text used for prompt as to activate specific ability.
             - `text` is the text used for generating real audio.
             - `spk` is the target speaker id to synthesize, corresponds to the prompt order. Default SPEAKER_0.
             - `prompt_wav` is the audio used for prompt.

soulxpodcast/utils/infer_utils.py

@@ -0,0 +1,95 @@
+import re
+import json
+import torch
+import argparse
+from tqdm import tqdm
+from datetime import datetime
+
+import s3tokenizer
+
+from soulxpodcast.models.soulxpodcast import SoulXPodcast
+from soulxpodcast.utils.dataloader import PodcastInferHandler
+from soulxpodcast.utils.commons import set_all_random_seed
+from soulxpodcast.config import Config, SoulXPodcastLLMConfig, SamplingParams
+
+
+def initiate_model(seed, model_path, llm_engine, fp16_flow):
+    set_all_random_seed(seed)
+
+    hf_config = SoulXPodcastLLMConfig.from_initial_and_json(
+        initial_values={"fp16_flow": fp16_flow},
+        json_file=f"{model_path}/soulxpodcast_config.json"
+    )
+    if llm_engine == "vllm":
+        import importlib.util
+        if not importlib.util.find_spec("vllm"):
+            llm_engine = "hf"
+            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:-3]
+            tqdm.write(f"[{timestamp}] - [WARNING]: No install VLLM, switch to hf engine.")
+
+    config = Config(model=model_path, enforce_eager=True, llm_engine=llm_engine, hf_config=hf_config)
+    model = SoulXPodcast(config)
+
+    dataset = PodcastInferHandler(model.llm.tokenizer, None, config)
+
+    return model, dataset
+
+
+def process_single_input(dataset, target_text_list, prompt_wav_list, prompt_text_list, use_dialect_prompt, dialect_prompt_text_list):
+    spks, texts = [], []
+    for target_text in target_text_list:
+        pattern = r'(\[S[1-9]\])(.+)'
+        match = re.match(pattern, target_text)
+        text, spk = match.group(2), int(match.group(1)[2])-1
+        spks.append(spk)
+        texts.append(text)
+
+    dataitem = {"key": "001", "prompt_text": prompt_text_list, "prompt_wav": prompt_wav_list,
+             "text": texts, "spk": spks, }
+    if use_dialect_prompt:
+        dataitem.update({
+            "dialect_prompt_text": dialect_prompt_text_list
+        })
+    dataset.update_datasource(
+        [
+           dataitem
+        ]
+    )
+
+
+    data = dataset[0]
+    prompt_mels_for_llm, prompt_mels_lens_for_llm = s3tokenizer.padding(data["log_mel"])
+    spk_emb_for_flow = torch.tensor(data["spk_emb"])
+    prompt_mels_for_flow = torch.nn.utils.rnn.pad_sequence(data["mel"], batch_first=True, padding_value=0)
+    prompt_mels_lens_for_flow = torch.tensor(data['mel_len'])
+    text_tokens_for_llm = data["text_tokens"]
+    prompt_text_tokens_for_llm = data["prompt_text_tokens"]
+    spk_ids = data["spks_list"]
+    sampling_params = SamplingParams(use_ras=True,win_size=25,tau_r=0.2)
+    infos = [data["info"]]
+    processed_data = {
+        "prompt_mels_for_llm": prompt_mels_for_llm,
+        "prompt_mels_lens_for_llm": prompt_mels_lens_for_llm,
+        "prompt_text_tokens_for_llm": prompt_text_tokens_for_llm,
+        "text_tokens_for_llm": text_tokens_for_llm,
+        "prompt_mels_for_flow_ori": prompt_mels_for_flow,
+        "prompt_mels_lens_for_flow": prompt_mels_lens_for_flow,
+        "spk_emb_for_flow": spk_emb_for_flow,
+        "sampling_params": sampling_params,
+        "spk_ids": spk_ids,
+        "infos": infos,
+        "use_dialect_prompt": use_dialect_prompt,
+    }
+    if use_dialect_prompt:
+        processed_data.update({
+            "dialect_prompt_text_tokens_for_llm": data["dialect_prompt_text_tokens"],
+            "dialect_prefix": data["dialect_prefix"],
+        })
+    return processed_data
+
+
+def check_models(model_path, inputs):
+    if inputs['use_dialect_prompt']:
+        assert 'dialect' in model_path, "Dialect prompt is used, you should use a dialect model."
+
+    return True

soulxpodcast/utils/parser.py

@@ -0,0 +1,87 @@
+import json
+import datetime
+import os
+
+
+def generate_time_index():
+    """Generate a time-based unique key, e.g. '20251023-001'."""
+    now = datetime.datetime.now()
+    return now.strftime("%Y%m%d-%H%M%S")
+
+def check_prefix(text):
+    prefixes = ["<|Henan|>", "<|Sichuan|>", "<|Yue|>"]
+
+    for prefix in prefixes:
+        if text.startswith(prefix):
+            return True
+    return False
+
+
+def podcast_format_parser(data, output_dir="outputs"):
+    """
+    Parse the original multi-speaker podcast JSON to the target flattened format.
+    The key will be a time-based unique ID.
+    Args:
+        data (dict): input JSON data with 'speakers' and 'text' fields
+        output_dir (str): directory for output wav file path
+    Returns:
+        dict: converted format
+    """
+    speakers = data.get("speakers", {})
+    text_entries = data.get("text", [])
+
+
+    spk2id = {name: idx for idx, name in enumerate(speakers.keys())}
+
+
+    prompt_text = []
+    prompt_wav = []
+    dialect_prompt_text = []
+
+    for name in speakers:
+        prompt_text.append(speakers[name].get("prompt_text", ""))
+        prompt_wav.append(speakers[name].get("prompt_audio", ""))
+        dialect_prompt_text.append(speakers[name].get("dialect_prompt", ""))
+
+
+    text_list = []
+    spk_list = []
+    for turn in text_entries:
+        if len(turn) == 2:
+            spk_name, utt_text = turn
+            text = f'[{spk_name}]{utt_text}'
+            text_list.append(text)
+            spk_list.append(spk2id.get(spk_name, -1))
+
+
+    key = generate_time_index()
+    wav_path = os.path.join(output_dir, f"{key}.wav")
+
+    use_dialect_prompt = False
+    for dialect_text in dialect_prompt_text:
+        if len(dialect_text) > 0:
+            assert check_prefix(dialect_text), f"Unknown dialect prefix: {dialect_text} \
+                            \n Prefix should be one of: <|Henan|>, <|Sichuan|>, <|Yue|>"
+            use_dialect_prompt = True
+
+    result = {
+        "key": key,
+        "prompt_text": prompt_text,
+        "prompt_wav": prompt_wav,
+        "text": text_list,
+        "spk": spk_list,
+        "wav": wav_path,
+        "use_dialect_prompt": use_dialect_prompt,
+        "dialect_prompt_text": dialect_prompt_text
+    }
+
+    return result
+
+
+
+if __name__ == "__main__":
+    with open("example/podcast_script/script_henan.json", "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    converted = podcast_format_parser(data)
+    print(json.dumps(converted, ensure_ascii=False, indent=2))

soulxpodcast/utils/text.py

@@ -1,5 +1,5 @@
 import re
-
+from typing import List
 
 def remove_space_between_chinese(text):
 
@@ -41,3 +41,42 @@ def normalize_text(current_text):
             current_text += "."
 
     return current_text
+
+
+def check_monologue_text(text: str, prefix: str = None) -> bool:
+    text = text.strip()
+
+    if prefix is not None and (not text.startswith(prefix)):
+        return False
+
+    if prefix is not None:
+        text = text.removeprefix(prefix)
+    text = text.strip()
+
+    if len(text) == 0:
+        return False
+    return True
+
+def check_dialect_prompt_text(text: str, prefix: str = None) -> bool:
+    text = text.strip()
+
+    if prefix is not None and (not text.startswith(prefix)):
+        return False
+    text = text.strip()
+
+    if len(text) == 0:
+        return False
+    return True
+
+def check_dialogue_text(text_list: List[str]) -> bool:
+    if len(text_list) == 0:
+        return False
+    for text in text_list:
+        if not (
+            check_monologue_text(text, "[S1]")
+            or check_monologue_text(text, "[S2]")
+            or check_monologue_text(text, "[S3]")
+            or check_monologue_text(text, "[S4]")
+        ):
+            return False
+    return True