msedge-tts 0.1.0

This library is a wrapper of **MSEdge Read aloud** function API. You can use it to synthesize text to speech with many voices MS provided.
Documentation 
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

use super::build_websocket_request;
use crate::error::Result;

pub type WebSocketStream =
    tungstenite::WebSocket<tungstenite::stream::MaybeTlsStream<std::net::TcpStream>>;

pub fn websocket_connect() -> Result<WebSocketStream> {
    use tungstenite::handshake::HandshakeError;
    use tungstenite::Error;

    let request = build_websocket_request()?;
    let stream = try_connect(&request)?;
    let connector = build_rustls_connector()?;
    let (websocket, _) =
        tungstenite::client_tls_with_config(request, stream, None, Some(connector)).map_err(
            |e| match e {
                HandshakeError::Failure(e) => e,
                e => Error::Io(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    e.to_string(),
                )),
            },
        )?;
    Ok(websocket)
}

fn try_connect(request: &tungstenite::handshake::client::Request) -> Result<std::net::TcpStream> {
    use tungstenite::error::UrlError;
    use tungstenite::Error;

    let uri = request.uri();
    let host = uri.host().ok_or(Error::Url(UrlError::NoHostName))?;
    let stream = std::net::TcpStream::connect((host, 443)).map_err(tungstenite::Error::from)?;
    stream.set_nodelay(true).map_err(tungstenite::Error::from)?;
    Ok(stream)
}

fn build_rustls_connector() -> Result<tungstenite::Connector> {
    let mut root_store = rustls::RootCertStore::empty();
    root_store.add_parsable_certificates(
        rustls_native_certs::load_native_certs().map_err(tungstenite::Error::from)?,
    );
    let mut client_config = rustls::ClientConfig::builder()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    client_config.key_log = std::sync::Arc::new(rustls::KeyLogFile::new());
    Ok(tungstenite::Connector::Rustls(std::sync::Arc::new(
        client_config,
    )))
}

pub type WebSocketStreamAsync = async_tungstenite::WebSocketStream<
    async_tungstenite::async_tls::ClientStream<async_net::TcpStream>,
>;

pub async fn websocket_connect_asnyc() -> Result<WebSocketStreamAsync> {
    use async_tungstenite::async_tls::client_async_tls_with_connector;

    let request = build_websocket_request()?;
    let stream = try_connect_async(&request).await?;
    let connector = build_async_tls_connector()?;
    let (websocket, _) = client_async_tls_with_connector(request, stream, Some(connector)).await?;
    Ok(websocket)
}

async fn try_connect_async(
    request: &tungstenite::handshake::client::Request,
) -> Result<async_net::TcpStream> {
    use tungstenite::error::UrlError;
    use tungstenite::Error;

    let uri = request.uri();
    let host = uri.host().ok_or(Error::Url(UrlError::NoHostName))?;
    let stream = async_net::TcpStream::connect((host, 443))
        .await
        .map_err(tungstenite::Error::from)?;
    Ok(stream)
}

fn build_async_tls_connector() -> Result<async_tls::TlsConnector> {
    let certs: Vec<_> = rustls_native_certs::load_native_certs()
        .map_err(tungstenite::Error::from)?
        .into_iter()
        .map(|x| x.to_vec())
        .collect();
    let mut root_store = old_rustls::RootCertStore::empty();
    root_store.add_parsable_certificates(&certs);
    let mut client_config = old_rustls::ClientConfig::builder()
        .with_safe_defaults()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    client_config.key_log = std::sync::Arc::new(old_rustls::KeyLogFile::new());
    Ok(async_tls::TlsConnector::from(client_config))
}