File size: 9,084 Bytes
e4d8df5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 |
import re
import ssl
import json
import time
import uuid
import codecs
import certifi
import aiohttp
from io import TextIOWrapper
from dataclasses import dataclass
from contextlib import nullcontext
from xml.sax.saxutils import escape
@dataclass
class TTSConfig:
def __init__(self, voice, rate, volume, pitch):
self.voice = voice
self.rate = rate
self.volume = volume
self.pitch = pitch
@staticmethod
def validate_string_param(param_name, param_value, pattern):
if re.match(pattern, param_value) is None: raise ValueError(f"{param_name} '{param_value}'.")
return param_value
def __post_init__(self):
match = re.match(r"^([a-z]{2,})-([A-Z]{2,})-(.+Neural)$", self.voice)
if match is not None:
region = match.group(2)
name = match.group(3)
if name.find("-") != -1:
region = region + "-" + name[: name.find("-")]
name = name[name.find("-") + 1 :]
self.voice = ("Microsoft Server Speech Text to Speech Voice" + f" ({match.group(1)}-{region}, {name})")
self.validate_string_param("voice", self.voice, r"^Microsoft Server Speech Text to Speech Voice \(.+,.+\)$")
self.validate_string_param("rate", self.rate, r"^[+-]\d+%$")
self.validate_string_param("volume", self.volume, r"^[+-]\d+%$")
self.validate_string_param("pitch", self.pitch, r"^[+-]\d+Hz$")
def get_headers_and_data(data, header_length):
headers = {}
for line in data[:header_length].split(b"\r\n"):
key, value = line.split(b":", 1)
headers[key] = value
return headers, data[header_length + 2 :]
def date_to_string():
return time.strftime("%a %b %d %Y %H:%M:%S GMT+0000 (Coordinated Universal Time)", time.gmtime())
def mkssml(tc, escaped_text):
if isinstance(escaped_text, bytes): escaped_text = escaped_text.decode("utf-8")
return (f"<speak version='1.0' xmlns='{codecs.decode('uggc://jjj.j3.bet/2001/10/flagurfvf', 'rot13')}' xml:lang='en-US'>" f"<voice name='{tc.voice}'>" f"<prosody pitch='{tc.pitch}' rate='{tc.rate}' volume='{tc.volume}'>" f"{escaped_text}" "</prosody>" "</voice>" "</speak>")
def connect_id():
return str(uuid.uuid4()).replace("-", "")
def ssml_headers_plus_data(request_id, timestamp, ssml):
return (f"X-RequestId:{request_id}\r\n" "Content-Type:application/ssml+xml\r\n" f"X-Timestamp:{timestamp}Z\r\n" "Path:ssml\r\n\r\n" f"{ssml}")
def remove_incompatible_characters(string):
if isinstance(string, bytes): string = string.decode("utf-8")
chars = list(string)
for idx, char in enumerate(chars):
code = ord(char)
if (0 <= code <= 8) or (11 <= code <= 12) or (14 <= code <= 31): chars[idx] = " "
return "".join(chars)
def split_text_by_byte_length(text, byte_length):
if isinstance(text, str): text = text.encode("utf-8")
if byte_length <= 0: raise ValueError("byte_length > 0")
while len(text) > byte_length:
split_at = text.rfind(b" ", 0, byte_length)
split_at = split_at if split_at != -1 else byte_length
while b"&" in text[:split_at]:
ampersand_index = text.rindex(b"&", 0, split_at)
if text.find(b";", ampersand_index, split_at) != -1: break
split_at = ampersand_index - 1
if split_at == 0: break
new_text = text[:split_at].strip()
if new_text: yield new_text
if split_at == 0: split_at = 1
text = text[split_at:]
new_text = text.strip()
if new_text: yield new_text
class Communicate:
def __init__(self, text, voice, *, rate="+0%", volume="+0%", pitch="+0Hz", proxy=None, connect_timeout=10, receive_timeout=60):
self.tts_config = TTSConfig(voice, rate, volume, pitch)
self.texts = split_text_by_byte_length(escape(remove_incompatible_characters(text)), 2**16 - (len(ssml_headers_plus_data(connect_id(), date_to_string(), mkssml(self.tts_config, ""))) + 50))
self.proxy = proxy
self.session_timeout = aiohttp.ClientTimeout(total=None, connect=None, sock_connect=connect_timeout, sock_read=receive_timeout)
self.state = {"partial_text": None, "offset_compensation": 0, "last_duration_offset": 0, "stream_was_called": False}
def __parse_metadata(self, data):
for meta_obj in json.loads(data)["Metadata"]:
meta_type = meta_obj["Type"]
if meta_type == "WordBoundary": return {"type": meta_type, "offset": (meta_obj["Data"]["Offset"] + self.state["offset_compensation"]), "duration": meta_obj["Data"]["Duration"], "text": meta_obj["Data"]["text"]["Text"]}
if meta_type in ("SessionEnd",): continue
async def __stream(self):
async def send_command_request():
await websocket.send_str(f"X-Timestamp:{date_to_string()}\r\n" "Content-Type:application/json; charset=utf-8\r\n" "Path:speech.config\r\n\r\n" '{"context":{"synthesis":{"audio":{"metadataoptions":{' '"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},' '"outputFormat":"audio-24khz-48kbitrate-mono-mp3"' "}}}}\r\n")
async def send_ssml_request():
await websocket.send_str(ssml_headers_plus_data(connect_id(), date_to_string(), mkssml(self.tts_config, self.state["partial_text"])))
audio_was_received = False
ssl_ctx = ssl.create_default_context(cafile=certifi.where())
async with aiohttp.ClientSession(trust_env=True, timeout=self.session_timeout) as session, session.ws_connect(f"wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1?TrustedClientToken=6A5AA1D4EAFF4E9FB37E23D68491D6F4&ConnectionId={connect_id()}", compress=15, proxy=self.proxy, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" " (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36" " Edg/130.0.0.0", "Accept-Encoding": "gzip, deflate, br", "Accept-Language": "en-US,en;q=0.9", "Pragma": "no-cache", "Cache-Control": "no-cache", "Origin": "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold"}, ssl=ssl_ctx) as websocket:
await send_command_request()
await send_ssml_request()
async for received in websocket:
if received.type == aiohttp.WSMsgType.TEXT:
encoded_data: bytes = received.data.encode("utf-8")
parameters, data = get_headers_and_data(encoded_data, encoded_data.find(b"\r\n\r\n"))
path = parameters.get(b"Path", None)
if path == b"audio.metadata":
parsed_metadata = self.__parse_metadata(data)
yield parsed_metadata
self.state["last_duration_offset"] = (parsed_metadata["offset"] + parsed_metadata["duration"])
elif path == b"turn.end":
self.state["offset_compensation"] = self.state["last_duration_offset"]
self.state["offset_compensation"] += 8_750_000
break
elif received.type == aiohttp.WSMsgType.BINARY:
if len(received.data) < 2: raise Exception("received.data < 2")
header_length = int.from_bytes(received.data[:2], "big")
if header_length > len(received.data): raise Exception("header_length > received.data")
parameters, data = get_headers_and_data(received.data, header_length)
if parameters.get(b"Path") != b"audio": raise Exception("Path != audio")
content_type = parameters.get(b"Content-Type", None)
if content_type not in [b"audio/mpeg", None]: raise Exception("content_type != audio/mpeg")
if content_type is None and len(data) == 0: continue
if len(data) == 0: raise Exception("data = 0")
audio_was_received = True
yield {"type": "audio", "data": data}
if not audio_was_received: raise Exception("!audio_was_received")
async def stream(self):
if self.state["stream_was_called"]: raise RuntimeError("stream_was_called")
self.state["stream_was_called"] = True
for self.state["partial_text"] in self.texts:
async for message in self.__stream():
yield message
async def save(self, audio_fname, metadata_fname = None):
metadata = (open(metadata_fname, "w", encoding="utf-8") if metadata_fname is not None else nullcontext())
with metadata, open(audio_fname, "wb") as audio:
async for message in self.stream():
if message["type"] == "audio": audio.write(message["data"])
elif (isinstance(metadata, TextIOWrapper) and message["type"] == "WordBoundary"):
json.dump(message, metadata)
metadata.write("\n") |