/// <summary> /// Generate a presigned URL based on a <see cref="SynthesizeSpeechRequest"/>. /// </summary> /// <param name="credentials">The credentials to use in the presigned URL.</param> /// <param name="region">The region for the URL.</param> /// <param name="request">The request to base the presigned URL on.</param> /// <returns></returns> public static string GeneratePresignedUrl(AWSCredentials credentials, RegionEndpoint region, SynthesizeSpeechRequest request) { if (credentials == null) throw new ArgumentNullException("credentials"); if (region == null) throw new ArgumentNullException("region"); if (request == null) throw new ArgumentNullException("request"); // Marshall this request and prepare it to be signed var marshaller = new SynthesizeSpeechRequestMarshaller(); var iRequest = marshaller.Marshall(request); iRequest.UseQueryString = true; iRequest.HttpMethod = HTTPGet; iRequest.Endpoint = new UriBuilder(HTTPS, region.GetEndpointForService(PollyServiceName).Hostname).Uri; iRequest.Parameters[XAmzExpires] = ((int)FifteenMinutes.TotalSeconds).ToString(CultureInfo.InvariantCulture); if (request.IsSetLexiconNames()) { var sortedLexiconNames = new List<string>(request.LexiconNames); sortedLexiconNames.Sort(StringComparer.Ordinal); iRequest.Parameters[LexiconNamesParameter] = JsonMapper.ToJson(sortedLexiconNames); } if (request.IsSetOutputFormat()) iRequest.Parameters["OutputFormat"] = request.OutputFormat.ToString(); if (request.IsSetSampleRate()) iRequest.Parameters["SampleRate"] = request.SampleRate.ToString(); if (request.IsSetText()) iRequest.Parameters["Text"] = request.Text; if (request.IsSetTextType()) iRequest.Parameters["TextType"] = request.TextType.ToString(); if (request.IsSetVoiceId()) iRequest.Parameters["VoiceId"] = request.VoiceId; var immutableCredentials = credentials.GetCredentials(); if (immutableCredentials.UseToken) { // Don't use HeaderKeys.XAmzSecurityTokenHeader because Polly treats this as case-sensitive iRequest.Parameters["X-Amz-Security-Token"] = immutableCredentials.Token; } // Only the host header should be signed, and the signer adds that. // So clear out headers. iRequest.Headers.Clear(); // Create presigned URL and assign it var signingResult = SynthesizeSpeechPresignedUrlSigner.SignSynthesizeSpeechRequest(iRequest, new RequestMetrics(), immutableCredentials.AccessKey, immutableCredentials.SecretKey, PollyServiceName, region.SystemName); var authorization = "&" + signingResult.ForQueryParameters; return ComposeUrl(iRequest).AbsoluteUri + authorization; }
public void TestLexiconNames1() { var request = new SynthesizeSpeechRequest() { LexiconNames = new List<string>() { "lex1" } }; var url = SynthesizeSpeechUtil.GeneratePresignedUrl(RegionEndpoint.USWest2, request); Assert.IsTrue(url.Contains("LexiconNames=lex1")); }
private Amazon.Polly.Model.SynthesizeSpeechResponse CallAWSServiceOperation(IAmazonPolly client, Amazon.Polly.Model.SynthesizeSpeechRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Polly", "SynthesizeSpeech"); try { #if DESKTOP return(client.SynthesizeSpeech(request)); #elif CORECLR return(client.SynthesizeSpeechAsync(request).GetAwaiter().GetResult()); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } }
public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.Polly.Model.SynthesizeSpeechRequest(); if (cmdletContext.Engine != null) { request.Engine = cmdletContext.Engine; } if (cmdletContext.LanguageCode != null) { request.LanguageCode = cmdletContext.LanguageCode; } if (cmdletContext.LexiconName != null) { request.LexiconNames = cmdletContext.LexiconName; } if (cmdletContext.OutputFormat != null) { request.OutputFormat = cmdletContext.OutputFormat; } if (cmdletContext.SampleRate != null) { request.SampleRate = cmdletContext.SampleRate; } if (cmdletContext.SpeechMarkType != null) { request.SpeechMarkTypes = cmdletContext.SpeechMarkType; } if (cmdletContext.Text != null) { request.Text = cmdletContext.Text; } if (cmdletContext.TextType != null) { request.TextType = cmdletContext.TextType; } if (cmdletContext.VoiceId != null) { request.VoiceId = cmdletContext.VoiceId; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return(output); }
/// <summary> /// Generate a presigned URL based on a <see cref="SynthesizeSpeechRequest"/> /// using the default configured credentials. /// </summary> /// <param name="region">The region for the URL.</param> /// <param name="request">The request to base the presigned URL on.</param> /// <returns></returns> public static string GeneratePresignedUrl(RegionEndpoint region, SynthesizeSpeechRequest request) { AWSCredentials credentials = FallbackCredentialsFactory.GetCredentials(); return GeneratePresignedUrl(credentials, region, request); }
/// <summary> /// Initiates the asynchronous execution of the SynthesizeSpeech operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the SynthesizeSpeech operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<SynthesizeSpeechResponse> SynthesizeSpeechAsync(SynthesizeSpeechRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new SynthesizeSpeechRequestMarshaller(); var unmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance; return InvokeAsync<SynthesizeSpeechRequest,SynthesizeSpeechResponse>(request, marshaller, unmarshaller, cancellationToken); }
/// <summary> /// Synthesizes UTF-8 input, plain text or SSML, to a stream of bytes. SSML input must /// be valid, well-formed SSML. Some alphabets might not be available with all the voices /// (for example, Cyrillic might not be read at all by English voices) unless phoneme /// mapping is used. For more information, see <a href="http://docs.aws.amazon.com/polly/latest/dg/how-text-to-speech-works.html">How /// it Works</a>. /// </summary> /// <param name="request">Container for the necessary parameters to execute the SynthesizeSpeech service method.</param> /// /// <returns>The response from the SynthesizeSpeech service method, as returned by Polly.</returns> /// <exception cref="Amazon.Polly.Model.InvalidSampleRateException"> /// The specified sample rate is not valid. /// </exception> /// <exception cref="Amazon.Polly.Model.InvalidSsmlException"> /// The SSML you provided is invalid. Verify the SSML syntax, spelling of tags and values, /// and then try again. /// </exception> /// <exception cref="Amazon.Polly.Model.LexiconNotFoundException"> /// Amazon Polly can't find the specified lexicon. This could be caused by a lexicon that /// is missing, its name is misspelled or specifying a lexicon that is in a different /// region. /// /// /// <para> /// Verify that the lexicon exists, is in the region (see <a>ListLexicons</a>) and that /// you spelled its name is spelled correctly. Then try again. /// </para> /// </exception> /// <exception cref="Amazon.Polly.Model.ServiceFailureException"> /// An unknown condition has caused a service failure. /// </exception> /// <exception cref="Amazon.Polly.Model.TextLengthExceededException"> /// The value of the "Text" parameter is longer than the accepted limits. The limit for /// input text is a maximum of 3000 characters total, of which no more than 1500 can be /// billed characters. SSML tags are not counted as billed characters. /// </exception> public SynthesizeSpeechResponse SynthesizeSpeech(SynthesizeSpeechRequest request) { var marshaller = new SynthesizeSpeechRequestMarshaller(); var unmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance; return Invoke<SynthesizeSpeechRequest,SynthesizeSpeechResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initiates the asynchronous execution of the SynthesizeSpeech operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the SynthesizeSpeech operation on AmazonPollyClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSynthesizeSpeech /// operation.</returns> public IAsyncResult BeginSynthesizeSpeech(SynthesizeSpeechRequest request, AsyncCallback callback, object state) { var marshaller = new SynthesizeSpeechRequestMarshaller(); var unmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance; return BeginInvoke<SynthesizeSpeechRequest>(request, marshaller, unmarshaller, callback, state); }
public void TestLexiconNamesNull() { var request = new SynthesizeSpeechRequest(); var url = SynthesizeSpeechUtil.GeneratePresignedUrl(RegionEndpoint.USWest2, request); Assert.IsFalse(url.Contains("LexiconNames")); }