private async void GetEnrollmentOperationStatus(OperationLocation location) { try { while (true) { EnrollmentOperation result = await _speakerIdentificationClient.CheckEnrollmentStatusAsync(location); if (result.Status != Status.Running) { RaiseOnIdentificationStatusUpdated(new SpeakerIdentificationStatusUpdateEventArgs(result.Status.ToString(), $"Enrollment finished. Enrollment status: {result.ProcessingResult.EnrollmentStatus.ToString()}")); break; } RaiseOnIdentificationStatusUpdated(new SpeakerIdentificationStatusUpdateEventArgs(result.Status.ToString(), "Enrolling...")); await Task.Delay(1000); } } catch (IdentificationException ex) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs($"Failed to get operation status: {ex.Message}")); } catch (Exception ex) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs($"Failed to get operation status: {ex.Message}")); } }
internal void Insert() { var database = client.GetDatabase(databaseName); IMongoCollection <Operation> collection = database.GetCollection <Operation>(collectionName); var result = new List <Operation>(operationCount); for (int i = 0; i < operationCount; i++) { var operation = new Operation { Id = Guid.NewGuid(), Comment = $"{i}", CreatedOn = DateTime.Now, OperationState = Beezie.Domain.Enums.OperationStates.Finalized, OperationType = i % 1000 == 0 ? Beezie.Domain.Enums.OperationTypes.Inventory : Beezie.Domain.Enums.OperationTypes.Out, }; var operationLocations = new List <OperationLocation>(); for (int j = 0; j < operationLocationCount; j++) { var operationLocation = new OperationLocation { Id = Guid.NewGuid(), OperationLocationType = operation.OperationType == Beezie.Domain.Enums.OperationTypes.Inventory ? Beezie.Domain.Enums.OperationLocationTypes.Inventory : Beezie.Domain.Enums.OperationLocationTypes.Sale, StorageId = 42, }; var operationDetails = new List <OperationDetail>(); for (int k = 0; k < operationDetailCount; k++) { var operationDetail = new OperationDetail { Id = Guid.NewGuid(), CreatedOn = DateTime.Now, FinalizedOn = DateTime.Now.AddMinutes(5), PaidOn = DateTime.Now.AddMinutes(5), PriceId = 42, ProductLocationId = k, Quantity = 42 * k + 1 }; operationDetails.Add(operationDetail); } operationLocation.OperationDetails = operationDetails; operationLocations.Add(operationLocation); } operation.OperationLocations = operationLocations; result.Add(operation); } collection.InsertMany(result); Console.WriteLine($"insert {operationCount}*{operationLocationCount}*{operationDetailCount} = {operationCount * operationLocationCount * operationDetailCount}"); }
public virtual IdentificationOperation CheckIdentificationStatus(OperationLocation location) { return(PolicyService.ExecuteRetryAndCapture400Errors( "SpeakerVerificationService.CheckIdentificationStatus", ApiKeys.SpeakerRecognitionRetryInSeconds, () => { var result = SpeakerIdentificationRepository.CheckIdentificationStatus(location); return result; }, null)); }
/// <summary> /// Gets the enrollment operation status or result asynchronously /// </summary> /// <param name="location">The location returned upon enrollment</param> /// <exception cref="EnrollmentException">Thrown in case of internal server error or an invalid url</exception> /// <exception cref="TimeoutException">Thrown in case the connection timed out</exception> /// <returns>The enrollment object encapsulating the result</returns> public async Task <EnrollmentOperation> CheckEnrollmentStatusAsync(OperationLocation location) { try { EnrollmentOperation operation = await CheckStatusAsync <EnrollmentOperation, EnrollmentException>(location.Url).ConfigureAwait(false); return(operation); } catch (TaskCanceledException exception) { throw new TimeoutException("Connection timed out: " + exception.Message); } }
// ================ public OperationContext( CancellationToken cancellationToken = default(CancellationToken), TimeSpan?timeout = null, [CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = 0 ) { CancellationToken = cancellationToken; _values = OperationValueDictionary.Empty; _created = _tick.Elapsed; _timeout = timeout ?? TimeSpan.FromMinutes(5); // Azure function default timeout _location = new OperationLocation(memberName, filePath, lineNumber); }
public virtual IdentificationOperation CheckIdentificationStatus(OperationLocation location) { try { var result = SpeakerIdentificationRepository.CheckIdentificationStatus(location); return(result); } catch (Exception ex) { Logger.Error("SpeakerIdentificationService.CheckIdentificationStatus failed", this, ex); } return(null); }
/// <summary> /// Enrolls a speaker profile from an audio stream asynchronously /// </summary> /// <param name="audioStream">The audio stream to use for enrollment</param> /// <param name="id">The speaker profile ID to enroll</param> /// <exception cref="EnrollmentException">Thrown in case of invalid audio format, internal server error or an invalid ID</exception> /// <exception cref="TimeoutException">Thrown in case the connection timed out</exception> /// <returns>The operation location object encapsulating the Url that can be used to check the status of the operation</returns> public async Task <OperationLocation> EnrollAsync(Stream audioStream, Guid id) { try { // Send the request string requestUri = _IDENTIFICATION_PROFILE_URI + "/" + id.ToString("D") + "/enroll"; OperationLocation location = await OperationAsync <EnrollmentException>(audioStream, requestUri).ConfigureAwait(false); return(location); } catch (TaskCanceledException exception) { throw new TimeoutException("Connection timed out: " + exception.Message); } }
public virtual EnrollmentOperation CheckEnrollmentStatus(OperationLocation location) { try { var result = Task.Run(async() => await SpeakerIdentificationRepository.CheckEnrollmentStatusAsync(location)).Result; return(result); } catch (Exception ex) { Logger.Error("SpeakerIdentificationService.CheckEnrollmentStatus failed", this, ex); } return(null); }
private void EnrollSpeaker(Stream stream) { // Reset pointer stream.Seek(0, SeekOrigin.Begin); SpeakerIdentificationServiceClient speakerIDClient = new SpeakerIdentificationServiceClient("c6b005dcf13e45b6a91485d38763277b"); //Creating Speaker Profile... CreateProfileResponse creationResponse = speakerIDClient.CreateProfileAsync("en-US").Result; //Speaker Profile Created. //Retrieving The Created Profile... Profile profile = speakerIDClient.GetProfileAsync(creationResponse.ProfileId).Result; //Speaker Profile Retrieved." //Enrolling Speaker OperationLocation processPollingLocation = speakerIDClient.EnrollAsync(stream, profile.ProfileId, false).Result; EnrollmentOperation enrollmentResult; int numOfRetries = 10; TimeSpan timeBetweenRetries = TimeSpan.FromSeconds(5.0); while (numOfRetries > 0) { Task.Delay(timeBetweenRetries); enrollmentResult = speakerIDClient.CheckEnrollmentStatusAsync(processPollingLocation).Result; if (enrollmentResult.Status == Status.Succeeded) { break; } else if (enrollmentResult.Status == Status.Failed) { throw new EnrollmentException(enrollmentResult.Message); } numOfRetries--; } if (numOfRetries <= 0) { throw new EnrollmentException("Enrollment operation timeout."); } //Enrollment Done. // Store profile in memory cache ObjectCache memCache = MemoryCache.Default; var profiles = memCache.Get("SpeakerProfiles") != null?memCache.Get("SpeakerProfiles") as List <Profile> : new List <Profile>(); memCache.Remove("SpeakerProfiles"); memCache.Add("SpeakerProfiles", profiles, DateTimeOffset.UtcNow.AddHours(2)); }
private OperationContext( OperationContext parent, CancellationToken cancellationToken, OperationValueDictionary values, TimeSpan created, TimeSpan timeout, OperationLocation location ) { _parent = parent; CancellationToken = cancellationToken; _values = values; _created = created; _timeout = timeout; _location = location; }
/// <summary> /// Identifies an audio stream asynchronously /// </summary> /// <param name="audioStream">The audio stream to identify</param> /// <param name="ids">The list of possible speaker profile IDs to identify from</param> /// <exception cref="IdentificationException">Thrown on cases of internal server error, invalid IDs or wrong audio format</exception> /// <exception cref="TimeoutException">Thrown in case the connection timed out</exception> /// <returns>An object encapsulating the The Url that can be used to query the identification operation status</returns> public async Task <OperationLocation> IdentifyAsync(Stream audioStream, Guid[] ids) { try { // Construct the request URI string testProfileIds = string.Join(",", ids.Select(id => id.ToString("D"))); string requestUri = _IDENTIFICATION_URI + "?identificationProfileIds=" + testProfileIds; OperationLocation location = await OperationAsync <IdentificationException>(audioStream, requestUri).ConfigureAwait(false); return(location); } catch (TaskCanceledException exception) { throw new TimeoutException("Connection timed out: " + exception.Message); } }
/// <summary> /// Identify a stream of audio /// </summary> /// <param name="stream">Audio buffer to be recognized</param> /// <param name="serviceClient">Client used in identifying the streamed audio wave</param> /// <param name="clientId">Client ID</param> /// <param name="requestId">Request ID</param> public async Task IdentifyStreamAsync(Stream stream, SpeakerIdentificationServiceClient serviceClient, Guid clientId, int requestId) { try { OperationLocation processPollingLocation = await serviceClient.IdentifyAsync(stream, _speakerIds, true).ConfigureAwait(false); var numberOfPollingRetries = 3; while (numberOfPollingRetries > 0) { await Task.Delay(TimeSpan.FromSeconds(TimeSpanBetweenPollingRetries)); IdentificationOperation identificationResponse = await serviceClient.CheckIdentificationStatusAsync(processPollingLocation); if (identificationResponse.Status == Status.Succeeded) { var result = new RecognitionResult(identificationResponse.ProcessingResult, clientId, requestId); _resultCallback(result); break; } if (identificationResponse.Status == Status.Failed) { var failureResult = new RecognitionResult(false, identificationResponse.Message, requestId); _resultCallback(failureResult); return; } numberOfPollingRetries--; } if (numberOfPollingRetries <= 0) { var failureResult = new RecognitionResult(false, "Request timeout.", requestId); _resultCallback(failureResult); } } catch (Exception ex) { var result = new RecognitionResult(false, ex.Message, requestId); _resultCallback(result); } }
private void RecognizeSpeaker(Stream stream) { // Reset pointer stream.Seek(0, SeekOrigin.Begin); SpeakerIdentificationServiceClient speakerIDClient = new SpeakerIdentificationServiceClient("c6b005dcf13e45b6a91485d38763277b"); // Fetch existing profiles ObjectCache memCache = MemoryCache.Default; var profiles = memCache.Get("SpeakerProfiles") != null?memCache.Get("SpeakerProfiles") as List <Profile> : new List <Profile>(); List <Guid> testProfileIds = (from prof in profiles select prof.ProfileId).ToList(); OperationLocation processPollingLocation = speakerIDClient.IdentifyAsync(stream, testProfileIds.ToArray(), false).Result; IdentificationOperation identificationResponse = null; int numOfRetries = 10; TimeSpan timeBetweenRetries = TimeSpan.FromSeconds(5.0); while (numOfRetries > 0) { Task.Delay(timeBetweenRetries); identificationResponse = speakerIDClient.CheckIdentificationStatusAsync(processPollingLocation).Result; if (identificationResponse.Status == Status.Succeeded) { break; } else if (identificationResponse.Status == Status.Failed) { throw new IdentificationException(identificationResponse.Message); } numOfRetries--; } if (numOfRetries <= 0) { throw new IdentificationException("Identification operation timeout."); } //"Identification Done." //Values now accessible!! var _identificationResultTxtBlk = identificationResponse.ProcessingResult.IdentifiedProfileId.ToString(); var _identificationConfidenceTxtBlk = identificationResponse.ProcessingResult.Confidence.ToString(); }
public async void IdentifySpeaker(Stream audioStream, Guid[] speakerIds) { try { OperationLocation location = await _speakerIdentificationClient.IdentifyAsync(audioStream, speakerIds); if (location == null) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs("Failed to identify speaker.")); return; } GetIdentificationOperationStatus(location); } catch (IdentificationException ex) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs($"Failed to identify speaker: {ex.Message}")); } catch (Exception ex) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs($"Failed to identify speaker: {ex.Message}")); } }
public async void CreateSpeakerEnrollment(Stream audioStream, Guid profileId) { try { OperationLocation location = await _speakerIdentificationClient.EnrollAsync(audioStream, profileId); if (location == null) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs("Failed to start enrollment process.")); return; } GetEnrollmentOperationStatus(location); } catch (IdentificationException ex) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs($"Failed to add speaker enrollment: {ex.Message}")); } catch (Exception ex) { RaiseOnIdentificationError(new SpeakerIdentificationErrorEventArgs($"Failed to add speaker enrollment: {ex.Message}")); } }
/// <summary> /// A helper method that's used to create an enrollment/identification request /// </summary> /// <typeparam name="E">The type of exception</typeparam> /// <param name="audioStream">The audio stream to enroll/identify from</param> /// <param name="requestUri">The Http endpoint for identification/enrollment</param> /// <returns>An operation object encoding the operation Url</returns> private async Task <OperationLocation> OperationAsync <E>(Stream audioStream, string requestUri) where E : Exception { var content = new MultipartFormDataContent("Upload----" + DateTime.Now.ToString("u")); content.Add(new StreamContent(audioStream), "Data", "testFile_" + DateTime.Now.ToString("u")); HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false); if (response.StatusCode == HttpStatusCode.Accepted) { IEnumerable <string> operationLocation = response.Headers.GetValues(_OPERATION_LOCATION_HEADER); if (operationLocation.Count() == 1) { string operationUrl = operationLocation.First(); OperationLocation location = new OperationLocation(); location.Url = operationUrl; return(location); } else { throw CreateExceptionFromType <E>("Incorrect server response"); } } else { string resultStr = await response.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorResponse errorResponse = JsonConvert.DeserializeObject <ErrorResponse>(resultStr); if (errorResponse.Error != null) { throw CreateExceptionFromType <E>(errorResponse.Error.Message); } else { throw CreateExceptionFromType <E>(response.StatusCode.ToString()); } } }
public virtual EnrollmentOperation CheckEnrollmentStatus(OperationLocation location) { var response = RepositoryClient.SendGet(ApiKeys.SpeakerRecognition, location.Url); return(JsonConvert.DeserializeObject <EnrollmentOperation>(response)); }
public virtual async Task <IdentificationOperation> CheckIdentificationStatusAsync(OperationLocation location) { var response = await RepositoryClient.SendGetAsync(ApiKeys.SpeakerRecognition, location.Url); return(JsonConvert.DeserializeObject <IdentificationOperation>(response)); }