from auralis import TTS, TTSRequest

# 初始化
tts = TTS().from_pretrained("AstraMindAI/xttsv2", gpt_model='AstraMindAI/xtts2-gpt')
# 基本生成
request = TTSRequest(
    text="你好，地球！这里是Auralis在说话。",
    speaker_files=["speaker.wav"]
)
output = tts.generate_speech(request)
output.save("hello.wav")

# 基本请求
request = TTSRequest(
    text="Hello world!",
    speaker_files=["speaker.wav"]
)

# 增强音频处理
request = TTSRequest(
    text="纯净的音质",
    speaker_files=["speaker.wav"],
    audio_config=AudioPreprocessingConfig(
        normalize=True,
        trim_silence=True,
        enhance_speech=True,
        enhance_amount=1.5
    )
)

# 语言特定请求
request = TTSRequest(
    text="Bonjour le monde!",
    speaker_files=["speaker.wav"],
    language="fr"
)

# 流式传输配置
request = TTSRequest(
    text="非常长的文本...",
    speaker_files=["speaker.wav"],
    stream=True,
)

# 生成参数
request = TTSRequest(
    text="创意变体",
    speaker_files=["speaker.wav"],
    temperature=0.8,
    top_p=0.9,
    top_k=50
)

# 加载音频文件
output = TTSOutput.from_file("input.wav")

# 格式转换
output.bit_depth = 32
output.channel = 2
tensor_audio = output.to_tensor()
audio_bytes = output.to_bytes()

# 音频处理
resampled = output.resample(target_sr=44100)
faster = output.change_speed(1.5)
num_samples、sample_rate、duration = output.get_info()

# 组合多个输出
combined = TTSOutput.combine_outputs([output1、output2、output3])

# 播放和保存
output.play()  # 播放音频
output.preview()  # 智能播放（Jupyter/系统）
output.save("processed.wav", sample_rate=44100)

# 处理多段相同声音的文本
texts = ["第一段。"、"第二段。"、"第三段。"]
requests = [
    TTSRequest(
        text=text,
        speaker_files=["speaker.wav"]
    ) for text in texts
]

# 顺序处理并显示进度
outputs = []
for i、req in enumerate(requests、1):
    print(f"正在处理第{i}篇/{len(requests)}")
    outputs.append(tts.generate_speech(req))

# 组合所有输出
combined = TTSOutput.combine_outputs(outputs)
combined.save("combined_output.wav")

def process_book(chapter_file: str、speaker_file: str):
    # 读取章节
    with open(chapter_file、'r') as f:
        chapter = f.read()
    
    # 您可以传入整本书，Auralis会自动分段处理
    
    request = TTSRequest(
            text=chapter，
            speaker_files=[speaker_file]，
            audio_config=AudioPreprocessingConfig(
                enhance_speech=True，
                normalize=True
            )
        )
        
    output = tts.generate_speech(request)
    
    output.play()
    output.save("chapter_output.wav")

import asyncio
from auralis import TTS, TTSRequest

async def generate_speech():
    tts = TTS().from_pretrained("AstraMindAI/xttsv2", gpt_model='AstraMindAI/xtts2-gpt')
    
    request = TTSRequest(
        text="Async generation example",
        speaker_files=["speaker.wav"]
    )
    
    output = await tts.generate_speech_async(request)
    output.save("async_output.wav")

asyncio.run(generate_speech())

async def generate_parallel():
    tts = TTS().from_pretrained("AstraMindAI/xttsv2", gpt_model='AstraMindAI/xtts2-gpt')
    
    # 创建多个请求
    requests = [
        TTSRequest(
            text=f"This is voice {i}",
            speaker_files=[f"speaker_{i}.wav"]
        ) for i in range(3)
    ]
    
    # 并行处理
    coroutines = [tts.generate_speech_async(req) for req in requests]
    outputs = await asyncio.gather(*coroutines, return_exceptions=True)
    
    # 处理结果
    valid_outputs = [
        out for out in outputs 
        if not isinstance(out, Exception)
    ]
    
    combined = TTSOutput.combine_outputs(valid_outputs)
    combined.save("parallel_output.wav")

asyncio.run(generate_parallel())

async def stream_multiple_texts():
    tts = TTS().from_pretrained("AstraMindAI/xttsv2", gpt_model='AstraMindAI/xtts2-gpt')
    
    # 准备流式请求
    texts = [
        "First long text...",
        "Second long text...",
        "Third long text..."
    ]
    
    requests = [
        TTSRequest(
            text=text,
            speaker_files=["speaker.wav"],
            stream=True,
        ) for text in texts
    ]
    
    # 并行处理流
    coroutines = [tts.generate_speech_async(req) for req in requests]
    streams = await asyncio.gather(*coroutines)
    
    # 收集输出
    output_container = {i: [] for i in range(len(requests))}
    
    async def process_stream(idx, stream):
        async for chunk in stream:
            output_container[idx].append(chunk)
            print(f"Processed chunk for text {idx+1}")
            
    # 处理所有流
    await asyncio.gather(
        *(process_stream(i, stream) 
          for i, stream in enumerate(streams))
    )
    
    # 保存结果
    for idx, chunks in output_container.items():
        TTSOutput.combine_outputs(chunks).save(
            f"text_{idx}_output.wav"
        )

asyncio.run(stream_multiple_texts())

@dataclass
class TTSRequest:
    """TTS 推理请求数据的容器"""
    # 请求元数据
    text: Union[AsyncGenerator[str, None], str, List[str]]

    speaker_files: Union[List[str], bytes]  # 发声人音频文件路径

    enhance_speech: bool = True
    audio_config: AudioPreprocessingConfig = field(default_factory=AudioPreprocessingConfig)
    language: SupportedLanguages = "auto"
    request_id: str = field(default_factory=lambda: uuid.uuid4().hex)
    load_sample_rate: int = 22050
    sound_norm_refs: bool = False

    # 声音调节参数
    max_ref_length: int = 60
    gpt_cond_len: int = 30
    gpt_cond_chunk_len: int = 4

    # 生成参数
    stream: bool = False
    temperature: float = 0.75
    top_p: float = 0.85
    top_k: int = 50
    repetition_penalty: float = 5.0
    length_penalty: float = 1.0
    do_sample: bool = True

示例

# 基本用法
request = TTSRequest(
    text="Hello world!",
    speaker_files=["reference.wav"]
)

# 自定义音频增强
request = TTSRequest(
    text="Hello world!",
    speaker_files=["reference.wav"],
    audio_config=AudioPreprocessingConfig(
        normalize=True,
        trim_silence=True,
        enhance_speech=True,
        enhance_amount=1.5
    )
)

# 流式传输长文本
request = TTSRequest(
    text="Very long text...",
    speaker_files=["reference.wav"],
    stream=True,
)

特性

• 自动语言检测
• 音频预处理与增强
• 灵活的输入处理（字符串、列表、生成器）
• 可配置的生成参数
• 缓存以提高处理效率

@dataclass
class TTSOutput:
    array: np.ndarray
    sample_rate: int

方法

格式转换

output.to_tensor()      # → torch.Tensor
output.to_bytes()       # → bytes (wav/raw)
output.from_tensor()    # → TTSOutput
output.from_file()      # → TTSOutput

音频处理

output.combine_outputs()  # 合并多个输出
output.resample()        # 更改采样率
output.get_info()        # 获取音频属性
output.change_speed()    # 修改播放速度

文件与播放

output.save()           # 保存到文件
output.play()          # 播放音频
output.display()       # 在 Jupyter 中显示
output.preview()       # 智能播放

示例

# 加载和处理
output = TTSOutput.from_file("input.wav")
output = output.resample(target_sr=44100)
output.save("output.wav")

# 合并多个输出
combined = TTSOutput.combine_outputs([output1, output2, output3])

# 改变播放速度
faster = output.change_speed(1.5)