public async Task ExtractSummaryBatchWithStatisticsTest()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractSummaryActions = new List <ExtractSummaryAction>()
{
new ExtractSummaryAction()
{
MaxSentenceCount = ExtractSummaryMaxSentenceCount
}
}
};
AnalyzeActionsOptions options = new AnalyzeActionsOptions()
{
IncludeStatistics = true
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_extractSummaryBatchDocuments, batchActions, options);
await operation.WaitForCompletionAsync();
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <ExtractSummaryActionResult> summaryActionsResults = resultCollection.ExtractSummaryResults;
ExtractSummaryResultCollection summaryDocumentsResults = summaryActionsResults.FirstOrDefault().DocumentsResults;
ValidateSummaryBatchResult(summaryDocumentsResults, includeStatistics: true);
}
public async Task ExtractSummaryBatchWithErrorTest()
{
TextAnalyticsClient client = GetClient();
var documents = new List <string>
{
"Subject is taking 100mg of ibuprofen twice daily",
"",
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractSummaryActions = new List <ExtractSummaryAction>()
{
new ExtractSummaryAction()
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(documents, batchActions, "en");
await operation.WaitForCompletionAsync();
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
List <ExtractSummaryActionResult> summaryActions = resultCollection.ExtractSummaryResults.ToList();
Assert.AreEqual(1, summaryActions.Count);
ExtractSummaryResultCollection documentsResults = summaryActions[0].DocumentsResults;
Assert.IsFalse(documentsResults[0].HasError);
Assert.IsTrue(documentsResults[1].HasError);
Assert.AreEqual(TextAnalyticsErrorCode.InvalidDocument, documentsResults[1].Error.ErrorCode.ToString());
}
public async Task ExtractSummaryWithDisableServiceLogs()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractSummaryActions = new List <ExtractSummaryAction>()
{
new ExtractSummaryAction()
{
DisableServiceLogs = true
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_extractSummaryBatchConvenienceDocuments, batchActions);
await operation.WaitForCompletionAsync();
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <ExtractSummaryActionResult> extractSummaryActionsResults = resultCollection.ExtractSummaryResults;
Assert.IsNotNull(extractSummaryActionsResults);
Assert.AreEqual(2, extractSummaryActionsResults.FirstOrDefault().DocumentsResults.Count);
}
public List <ResponseRecord> ExtractResult(AnalyzeActionsResult analyzeActionsResult)
{
var documents = ExtractDocumentsClassificationResult(analyzeActionsResult);
return(documents.Select(document =>
{
var documentRecord = new ResponseRecord
{
RecordId = document.Id
};
if (document.HasError)
{
documentRecord.Errors.Add(new ErrorWarning()
{
Message = $"Error processing the request record : {document.Error.Message}"
});
}
else
{
var classification = GetClassification(document);
var key = Constants.ResponseSingleClassKey;
documentRecord.Data.Add(key, classification);
}
return documentRecord;
}).ToList());
}
public List <ResponseRecord> ExtractResult(AnalyzeActionsResult analyzeActionsResult)
{
var documents = ExtractDocumentEntityResult(analyzeActionsResult);
return(documents.Select(document =>
{
var documentRecord = new ResponseRecord
{
RecordId = document.Id
};
if (document.HasError)
{
documentRecord.Errors.Add(new ErrorWarning()
{
Message = $"Error processing the request record : {document.Error.Message}"
});
}
else
{
// group entities by category
var entitiesResult = GetEntities(document); // entity.category -> list(entity.text)
// add to result
var key = Constants.ResponseEntitiesKey;
documentRecord.Data.Add(key, entitiesResult);
}
return documentRecord;
}).ToList());
}
public async Task SingleCategoryClassifyWithDisableServiceLogs()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
SingleCategoryClassifyActions = new List <SingleCategoryClassifyAction>()
{
new SingleCategoryClassifyAction(TestEnvironment.SingleClassificationProjectName, TestEnvironment.SingleClassificationDeploymentName)
{
DisableServiceLogs = true
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_singleCategoryClassifyBatchConvenienceDocuments, batchActions);
await PollUntilTimeout(operation);
Assert.IsTrue(operation.HasCompleted);
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <SingleCategoryClassifyActionResult> singleCategoryClassifyActionsResults = resultCollection.SingleCategoryClassifyResults;
Assert.IsNotNull(singleCategoryClassifyActionsResults);
Assert.AreEqual(2, singleCategoryClassifyActionsResults.FirstOrDefault().DocumentsResults.Count);
}
public async Task SingleCategoryClassifyBatchWithStatisticsTest()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
SingleCategoryClassifyActions = new List <SingleCategoryClassifyAction>()
{
new SingleCategoryClassifyAction(TestEnvironment.SingleClassificationProjectName, TestEnvironment.SingleClassificationDeploymentName)
}
};
AnalyzeActionsOptions options = new AnalyzeActionsOptions()
{
IncludeStatistics = true
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_singleCategoryClassifyBatchDocuments, batchActions, options);
await PollUntilTimeout(operation);
Assert.IsTrue(operation.HasCompleted);
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <SingleCategoryClassifyActionResult> singleCategoryClassifyActionsResults = resultCollection.SingleCategoryClassifyResults;
SingleCategoryClassifyResultCollection singleCategoryClassifyResults = singleCategoryClassifyActionsResults.FirstOrDefault().DocumentsResults;
ValidateSummaryBatchResult(singleCategoryClassifyResults, includeStatistics: true);
}
public async Task AnalyzeOperationTest()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
},
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchConvenienceDocuments, batchActions, "en");
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizeEntitiesActionResult> entitiesActionsResults = resultCollection.RecognizeEntitiesResults;
IReadOnlyCollection <ExtractKeyPhrasesActionResult> keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesResults;
IReadOnlyCollection <RecognizePiiEntitiesActionResult> piiActionsResults = resultCollection.RecognizePiiEntitiesResults;
IReadOnlyCollection <RecognizeLinkedEntitiesActionResult> entityLinkingActionsResults = resultCollection.RecognizeLinkedEntitiesResults;
IReadOnlyCollection <AnalyzeSentimentActionResult> analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentResults;
IReadOnlyCollection <ExtractSummaryActionResult> extractSummaryActionsResults = resultCollection.ExtractSummaryResults;
IReadOnlyCollection <RecognizeCustomEntitiesActionResult> recognizeCustomEntitiesActionResults = resultCollection.RecognizeCustomEntitiesResults;
IReadOnlyCollection <SingleCategoryClassifyActionResult> singleCategoryClassifyResults = resultCollection.SingleCategoryClassifyResults;
IReadOnlyCollection <MultiCategoryClassifyActionResult> multiCategoryClassifyResults = resultCollection.MultiCategoryClassifyResults;
Assert.IsNotNull(keyPhrasesActionsResults);
Assert.IsNotNull(entitiesActionsResults);
Assert.IsNotNull(piiActionsResults);
Assert.IsNotNull(entityLinkingActionsResults);
Assert.IsNotNull(analyzeSentimentActionsResults);
Assert.IsNotNull(extractSummaryActionsResults);
Assert.IsNotNull(singleCategoryClassifyResults);
Assert.IsNotNull(multiCategoryClassifyResults);
Assert.IsNotNull(recognizeCustomEntitiesActionResults);
var keyPhrasesListId1 = new List <string> {
"CEO", "SpaceX", "Elon Musk", "Tesla"
};
var keyPhrasesListId2 = new List <string> {
"Tesla stock"
};
ExtractKeyPhrasesResultCollection keyPhrasesDocumentsResults = keyPhrasesActionsResults.FirstOrDefault().DocumentsResults;
Assert.AreEqual(2, keyPhrasesDocumentsResults.Count);
foreach (string keyphrase in keyPhrasesDocumentsResults[0].KeyPhrases)
{
Assert.IsTrue(keyPhrasesListId1.Contains(keyphrase));
}
foreach (string keyphrase in keyPhrasesDocumentsResults[1].KeyPhrases)
{
Assert.IsTrue(keyPhrasesListId2.Contains(keyphrase));
}
}
public async Task MultiCategoryClassifyBatchTest()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
MultiCategoryClassifyActions = new List <MultiCategoryClassifyAction>()
{
new MultiCategoryClassifyAction(TestEnvironment.MultiClassificationProjectName, TestEnvironment.MultiClassificationDeploymentName)
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_multiCategoryClassifyBatchDocuments, batchActions);
await PollUntilTimeout(operation);
Assert.IsTrue(operation.HasCompleted);
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <MultiCategoryClassifyActionResult> multiCategoryClassifyActionsResults = resultCollection.MultiCategoryClassifyResults;
MultiCategoryClassifyResultCollection multiCategoryClassifyResults = multiCategoryClassifyActionsResults.FirstOrDefault().DocumentsResults;
ValidateSummaryBatchResult(multiCategoryClassifyResults);
}
public async Task AnalyzeOperationWithLanguageTest()
{
TextAnalyticsClient client = GetClient();
var batchDocuments = new List <TextDocumentInput>
{
new TextDocumentInput("1", "Microsoft was founded by Bill Gates and Paul Allen.")
{
Language = "en",
},
new TextDocumentInput("2", "Mi perro y mi gato tienen que ir al veterinario.")
{
Language = "es",
}
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
},
DisplayName = "AnalyzeOperationWithLanguageTest"
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchDocuments, batchActions);
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <ExtractKeyPhrasesActionResult> keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesActionsResults;
Assert.IsNotNull(keyPhrasesActionsResults);
ExtractKeyPhrasesResultCollection keyPhrasesResult = keyPhrasesActionsResults.FirstOrDefault().Result;
Assert.AreEqual(2, keyPhrasesResult.Count);
Assert.AreEqual("AnalyzeOperationWithLanguageTest", operation.DisplayName);
var keyPhrasesListId1 = new List <string> {
"Bill Gates", "Paul Allen", "Microsoft"
};
var keyPhrasesListId2 = new List <string> {
"gato", "perro", "veterinario"
};
foreach (string keyphrase in keyPhrasesResult[0].KeyPhrases)
{
Assert.IsTrue(keyPhrasesListId1.Contains(keyphrase));
}
foreach (string keyphrase in keyPhrasesResult[1].KeyPhrases)
{
Assert.IsTrue(keyPhrasesListId2.Contains(keyphrase));
}
}
private List <RecognizeEntitiesResult> ExtractDocumentEntityResult(AnalyzeActionsResult analyzeActionsResult)
{
/*
* select first(), becuase we only submit one action
* if we submitted multiple actions with different 'projectName', and 'deploymentName'
* we can select more than first()
*/
return(analyzeActionsResult.RecognizeCustomEntitiesResults.First()
.DocumentsResults.ToList());
}
public async Task AnalyzeOperationWithStatisticsTest()
{
TextAnalyticsClient client = GetClient();
var batchDocuments = new List <TextDocumentInput>
{
new TextDocumentInput("1", "Microsoft was founded by Bill Gates and Paul Allen.")
{
Language = "en",
},
new TextDocumentInput("2", "Mi perro y mi gato tienen que ir al veterinario.")
{
Language = "es",
},
new TextDocumentInput("3", "")
{
Language = "es",
}
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
},
DisplayName = "AnalyzeOperationTest",
};
AnalyzeActionsOptions options = new AnalyzeActionsOptions()
{
IncludeStatistics = true
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchDocuments, batchActions, options);
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
ExtractKeyPhrasesResultCollection result = resultCollection.ExtractKeyPhrasesActionsResults.ElementAt(0).Result;
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
Assert.AreEqual(3, result.Statistics.DocumentCount);
Assert.AreEqual(2, result.Statistics.TransactionCount);
Assert.AreEqual(2, result.Statistics.ValidDocumentCount);
Assert.AreEqual(1, result.Statistics.InvalidDocumentCount);
Assert.AreEqual(51, result[0].Statistics.CharacterCount);
Assert.AreEqual(1, result[0].Statistics.TransactionCount);
}
public async Task AnalyzeOperationWithPiiCategories()
{
TextAnalyticsClient client = GetClient();
var documents = new List <string>
{
"A developer with SSN 859-98-0987 whose phone number is 800-102-1100 is building tools with our APIs. They work at Microsoft.",
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
RecognizePiiEntitiesActions = new List <RecognizePiiEntitiesAction>()
{
new RecognizePiiEntitiesAction()
{
CategoriesFilter = { PiiEntityCategory.USSocialSecurityNumber }
}
},
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(documents, batchActions, "en");
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizePiiEntitiesActionResult> piiActionsResults = resultCollection.RecognizePiiEntitiesResults;
Assert.IsNotNull(piiActionsResults);
RecognizePiiEntitiesResultCollection piiDocumentsResults = piiActionsResults.FirstOrDefault().DocumentsResults;
Assert.AreEqual(1, piiDocumentsResults.Count);
Assert.IsNotEmpty(piiDocumentsResults[0].Entities.RedactedText);
Assert.IsFalse(piiDocumentsResults[0].HasError);
Assert.AreEqual(1, piiDocumentsResults[0].Entities.Count);
Assert.AreEqual(PiiEntityCategory.USSocialSecurityNumber, piiDocumentsResults[0].Entities.FirstOrDefault().Category);
}
public async Task AnalyzeOperationWithPHIDomain()
{
TextAnalyticsClient client = GetClient();
var documents = new List <string>
{
"A patient with medical id 12345678 whose phone number is 800-102-1100 is going under heart surgery",
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
RecognizePiiEntitiesActions = new List <RecognizePiiEntitiesAction>()
{
new RecognizePiiEntitiesAction()
{
DomainFilter = PiiEntityDomainType.ProtectedHealthInformation
}
},
DisplayName = "AnalyzeOperationWithPHIDomain",
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(documents, batchActions, "en");
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizePiiEntitiesActionResult> piiActionsResults = resultCollection.RecognizePiiEntitiesActionsResults;
Assert.IsNotNull(piiActionsResults);
RecognizePiiEntitiesResultCollection piiResult = piiActionsResults.FirstOrDefault().Result;
Assert.AreEqual(1, piiResult.Count);
Assert.IsNotEmpty(piiResult[0].Entities.RedactedText);
Assert.IsFalse(piiResult[0].HasError);
Assert.AreEqual(2, piiResult[0].Entities.Count);
}
public async Task RecognizeCustomEntitiesWithMultipleActions()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
RecognizeCustomEntitiesActions = new List <RecognizeCustomEntitiesAction>()
{
new RecognizeCustomEntitiesAction(TestEnvironment.RecognizeCustomEntitiesProjectName, TestEnvironment.RecognizeCustomEntitiesDeploymentName)
{
DisableServiceLogs = true,
ActionName = "RecognizeCustomEntitiesWithDisabledServiceLogs"
},
new RecognizeCustomEntitiesAction(TestEnvironment.RecognizeCustomEntitiesProjectName, TestEnvironment.RecognizeCustomEntitiesDeploymentName)
{
ActionName = "RecognizeCustomEntities"
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(e_batchConvenienceDocuments, batchActions);
await PollUntilTimeout(operation);
Assert.IsTrue(operation.HasCompleted);
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizeCustomEntitiesActionResult> RecognizeCustomEntitiesActionsResults = resultCollection.RecognizeCustomEntitiesResults;
Assert.IsNotNull(RecognizeCustomEntitiesActionsResults);
IList <string> expected = new List <string> {
"RecognizeCustomEntities", "RecognizeCustomEntitiesWithDisabledServiceLogs"
};
CollectionAssert.AreEquivalent(expected, RecognizeCustomEntitiesActionsResults.Select(result => result.ActionName));
}
public async Task MultiCategoryClassifyWithMultipleActions()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
MultiCategoryClassifyActions = new List <MultiCategoryClassifyAction>()
{
new MultiCategoryClassifyAction(TestEnvironment.MultiClassificationProjectName, TestEnvironment.MultiClassificationDeploymentName)
{
DisableServiceLogs = true,
ActionName = "MultiCategoryClassifyWithDisabledServiceLogs"
},
new MultiCategoryClassifyAction(TestEnvironment.MultiClassificationProjectName, TestEnvironment.MultiClassificationDeploymentName)
{
ActionName = "MultiCategoryClassify"
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_multiCategoryClassifyBatchConvenienceDocuments, batchActions);
await PollUntilTimeout(operation);
Assert.IsTrue(operation.HasCompleted);
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <MultiCategoryClassifyActionResult> multiCategoryClassifyActionsResults = resultCollection.MultiCategoryClassifyResults;
Assert.IsNotNull(multiCategoryClassifyActionsResults);
IList <string> expected = new List <string> {
"MultiCategoryClassify", "MultiCategoryClassifyWithDisabledServiceLogs"
};
CollectionAssert.AreEquivalent(expected, multiCategoryClassifyActionsResults.Select(result => result.ActionName));
}
public async Task AnalyzeOperationAnalyzeSentimentWithOpinionMining()
{
TextAnalyticsClient client = GetClient();
var documents = new List <string>
{
"The park was clean and pretty. The bathrooms and restaurant were not clean.",
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
AnalyzeSentimentActions = new List <AnalyzeSentimentAction>()
{
new AnalyzeSentimentAction()
{
IncludeOpinionMining = true
}
},
DisplayName = "AnalyzeOperationWithOpinionMining",
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(documents, batchActions);
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <AnalyzeSentimentActionResult> analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentActionsResults;
Assert.IsNotNull(analyzeSentimentActionsResults);
AnalyzeSentimentResultCollection analyzeSentimentResult = analyzeSentimentActionsResults.FirstOrDefault().Result;
Assert.AreEqual(1, analyzeSentimentResult.Count);
Assert.AreEqual(TextSentiment.Mixed, analyzeSentimentResult[0].DocumentSentiment.Sentiment);
}
private List <ResponseRecord> ExtractResults(AnalyzeActionsResult operationResult, List <ITextAnalyticsTask> targetTasks)
{
// extract action results
var allActionsResult = targetTasks.SelectMany(task => task.ExtractResult(operationResult));
// group results by document id
var documentGroups = allActionsResult.GroupBy(record => record.RecordId);
// extract action results
return(documentGroups.ToList().Select(documentGroup =>
{
var res = new ResponseRecord()
{
RecordId = documentGroup.Key
};
documentGroup.ToList().ForEach(action =>
{
action.Data.ToList().ForEach(entry => res.Data.Add(entry.Key, entry.Value));
res.Errors.AddRange(action.Errors);
});
return res;
}).ToList());
}
public async Task RecognizeLinkedEntitiesWithMultipleActions()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
RecognizeLinkedEntitiesActions = new List <RecognizeLinkedEntitiesAction>()
{
new RecognizeLinkedEntitiesAction()
{
DisableServiceLogs = true,
ActionName = "RecognizeLinkedEntitiesWithDisabledServiceLogs"
},
new RecognizeLinkedEntitiesAction()
{
ActionName = "RecognizeLinkedEntities"
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_batchDocuments, batchActions);
await operation.WaitForCompletionAsync();
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizeLinkedEntitiesActionResult> RecognizeLinkedEntitiesActionsResults = resultCollection.RecognizeLinkedEntitiesResults;
Assert.IsNotNull(RecognizeLinkedEntitiesActionsResults);
IList <string> expected = new List <string> {
"RecognizeLinkedEntities", "RecognizeLinkedEntitiesWithDisabledServiceLogs"
};
CollectionAssert.AreEquivalent(expected, RecognizeLinkedEntitiesActionsResults.Select(result => result.ActionName));
}
public async Task AnalyzeSentimentWithMultipleActions()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
AnalyzeSentimentActions = new List <AnalyzeSentimentAction>()
{
new AnalyzeSentimentAction()
{
DisableServiceLogs = true,
ActionName = "AnalyzeSentimentWithDisabledServiceLogs"
},
new AnalyzeSentimentAction()
{
ActionName = "AnalyzeSentiment"
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchConvenienceDocuments, batchActions);
await operation.WaitForCompletionAsync();
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <AnalyzeSentimentActionResult> AnalyzeSentimentActionsResults = resultCollection.AnalyzeSentimentResults;
Assert.IsNotNull(AnalyzeSentimentActionsResults);
IList <string> expected = new List <string> {
"AnalyzeSentiment", "AnalyzeSentimentWithDisabledServiceLogs"
};
CollectionAssert.AreEquivalent(expected, AnalyzeSentimentActionsResults.Select(result => result.ActionName));
}
public async Task ExtractSummaryWithMultipleActions()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractSummaryActions = new List <ExtractSummaryAction>()
{
new ExtractSummaryAction()
{
DisableServiceLogs = true,
ActionName = "ExtractSummaryWithDisabledServiceLogs"
},
new ExtractSummaryAction()
{
ActionName = "ExtractSummary"
}
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(s_extractSummaryBatchDocuments, batchActions);
await operation.WaitForCompletionAsync();
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <ExtractSummaryActionResult> ExtractSummaryActionsResults = resultCollection.ExtractSummaryResults;
Assert.IsNotNull(ExtractSummaryActionsResults);
IList <string> expected = new List <string> {
"ExtractSummary", "ExtractSummaryWithDisabledServiceLogs"
};
CollectionAssert.AreEquivalent(expected, ExtractSummaryActionsResults.Select(result => result.ActionName));
}
public async Task SingleCategoryClassifyBatchWithErrorTest()
{
TextAnalyticsClient client = GetClient();
var documents = new List <string>
{
"Subject is taking 100mg of ibuprofen twice daily",
"",
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
SingleCategoryClassifyActions = new List <SingleCategoryClassifyAction>()
{
new SingleCategoryClassifyAction(TestEnvironment.SingleClassificationProjectName, TestEnvironment.SingleClassificationDeploymentName)
}
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(documents, batchActions, "en");
await PollUntilTimeout(operation);
Assert.IsTrue(operation.HasCompleted);
// Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
List <SingleCategoryClassifyActionResult> singleCategoryClassifyActions = resultCollection.SingleCategoryClassifyResults.ToList();
Assert.AreEqual(1, singleCategoryClassifyActions.Count);
SingleCategoryClassifyResultCollection documentsResults = singleCategoryClassifyActions[0].DocumentsResults;
Assert.IsFalse(documentsResults[0].HasError);
Assert.IsTrue(documentsResults[1].HasError);
Assert.AreEqual(TextAnalyticsErrorCode.InvalidDocument, documentsResults[1].Error.ErrorCode.ToString());
}
public async Task AnalyzeOperationWithAADTest()
{
TextAnalyticsClient client = GetClient(useTokenCredential: true);
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
},
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchDocuments, batchActions);
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <ExtractKeyPhrasesActionResult> keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesActionsResults;
Assert.IsNotNull(keyPhrasesActionsResults);
Assert.AreEqual(2, keyPhrasesActionsResults.FirstOrDefault().Result.Count);
}
public async Task AnalyzeOperationAllActionsAndDisableServiceLogs()
{
TextAnalyticsClient client = GetClient();
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
{
DisableServiceLogs = true
}
},
RecognizeEntitiesActions = new List <RecognizeEntitiesAction>()
{
new RecognizeEntitiesAction()
{
DisableServiceLogs = true
}
},
RecognizePiiEntitiesActions = new List <RecognizePiiEntitiesAction>()
{
new RecognizePiiEntitiesAction()
{
DisableServiceLogs = false
}
},
RecognizeLinkedEntitiesActions = new List <RecognizeLinkedEntitiesAction>()
{
new RecognizeLinkedEntitiesAction()
{
DisableServiceLogs = true
}
},
AnalyzeSentimentActions = new List <AnalyzeSentimentAction>()
{
new AnalyzeSentimentAction()
{
DisableServiceLogs = true
}
},
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchConvenienceDocuments, batchActions);
await operation.WaitForCompletionAsync();
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <ExtractKeyPhrasesActionResult> keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesActionsResults;
IReadOnlyCollection <RecognizeEntitiesActionResult> entitiesActionsResults = resultCollection.RecognizeEntitiesActionsResults;
IReadOnlyCollection <RecognizePiiEntitiesActionResult> piiActionsResults = resultCollection.RecognizePiiEntitiesActionsResults;
IReadOnlyCollection <RecognizeLinkedEntitiesActionResult> entityLinkingActionsResults = resultCollection.RecognizeLinkedEntitiesActionsResults;
IReadOnlyCollection <AnalyzeSentimentActionResult> analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentActionsResults;
Assert.IsNotNull(keyPhrasesActionsResults);
Assert.AreEqual(2, keyPhrasesActionsResults.FirstOrDefault().Result.Count);
Assert.IsNotNull(entitiesActionsResults);
Assert.AreEqual(2, entitiesActionsResults.FirstOrDefault().Result.Count);
Assert.IsNotNull(piiActionsResults);
Assert.AreEqual(2, piiActionsResults.FirstOrDefault().Result.Count);
Assert.IsNotNull(entityLinkingActionsResults);
Assert.AreEqual(2, entityLinkingActionsResults.FirstOrDefault().Result.Count);
Assert.IsNotNull(analyzeSentimentActionsResults);
Assert.AreEqual(2, analyzeSentimentActionsResults.FirstOrDefault().Result.Count);
}
public async Task AnalyzeOperationWithActionsError()
{
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(@"
{
""displayName"": ""AnalyzeOperationBatchWithErrorTest"",
""jobId"": ""75d521bc-c2aa-4d8a-aabe-713e72d53a2d"",
""lastUpdateDateTime"": ""2021-03-03T22:39:37Z"",
""createdDateTime"": ""2021-03-03T22:39:36Z"",
""expirationDateTime"": ""2021-03-04T22:39:36Z"",
""status"": ""succeeded"",
""errors"": [
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/entityRecognitionPiiTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/entityRecognitionTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/keyPhraseExtractionTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/entityLinkingTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/sentimentAnalysisTasks/0""
}
],
""tasks"": {
""details"": {
""name"": ""AnalyzeOperationBatchWithErrorTest"",
""lastUpdateDateTime"": ""2021-03-03T22:39:37Z""
},
""completed"": 0,
""failed"": 5,
""inProgress"": 0,
""total"": 5,
""entityRecognitionTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""entityRecognitionPiiTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""keyPhraseExtractionTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""entityLinkingTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""sentimentAnalysisTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
]
}
}"));
var mockResponse = new MockResponse(200);
mockResponse.ContentStream = stream;
var mockTransport = new MockTransport(new[] { mockResponse });
var client = CreateTestClient(mockTransport);
var documents = new List <string>
{
"Elon Musk is the CEO of SpaceX and Tesla."
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
},
RecognizeEntitiesActions = new List <RecognizeEntitiesAction>()
{
new RecognizeEntitiesAction()
},
RecognizePiiEntitiesActions = new List <RecognizePiiEntitiesAction>()
{
new RecognizePiiEntitiesAction()
},
RecognizeLinkedEntitiesActions = new List <RecognizeLinkedEntitiesAction>()
{
new RecognizeLinkedEntitiesAction()
},
AnalyzeSentimentActions = new List <AnalyzeSentimentAction>()
{
new AnalyzeSentimentAction()
},
DisplayName = "AnalyzeOperationBatchWithErrorTest"
};
var operation = new AnalyzeActionsOperation("75d521bc-c2aa-4d8a-aabe-713e72d53a2d", client);
await operation.UpdateStatusAsync();
Assert.AreEqual(5, operation.ActionsFailed);
Assert.AreEqual(0, operation.ActionsSucceeded);
Assert.AreEqual(0, operation.ActionsInProgress);
Assert.AreEqual(5, operation.ActionsTotal);
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
RecognizeEntitiesActionResult entitiesActionsResults = resultCollection.RecognizeEntitiesResults.FirstOrDefault();
ExtractKeyPhrasesActionResult keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesResults.FirstOrDefault();
RecognizePiiEntitiesActionResult piiActionsResults = resultCollection.RecognizePiiEntitiesResults.FirstOrDefault();
RecognizeLinkedEntitiesActionResult entityLinkingActionsResults = resultCollection.RecognizeLinkedEntitiesResults.FirstOrDefault();
AnalyzeSentimentActionResult analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentResults.FirstOrDefault();
Assert.IsTrue(entitiesActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => entitiesActionsResults.DocumentsResults.GetType());
Assert.IsTrue(keyPhrasesActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => keyPhrasesActionsResults.DocumentsResults.GetType());
Assert.IsTrue(piiActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => piiActionsResults.DocumentsResults.GetType());
Assert.IsTrue(entityLinkingActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => entityLinkingActionsResults.DocumentsResults.GetType());
Assert.IsTrue(analyzeSentimentActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => analyzeSentimentActionsResults.DocumentsResults.GetType());
}
private List <SingleCategoryClassifyResult> ExtractDocumentsClassificationResult(AnalyzeActionsResult analyzeActionsResult)
{
/*
* select first(), becuase we only submit one action
* if we submitted multiple actions with different 'projectName', and 'deploymentName'
* we can select more than first()
*/
return(analyzeActionsResult.SingleCategoryClassifyResults.First().DocumentsResults.ToList());
}
public async Task AnalyzeOperationWithMultipleActionsOfSameType()
{
TextAnalyticsClient client = GetClient();
var batchDocuments = new List <TextDocumentInput>
{
new TextDocumentInput("1", "Microsoft was founded by Bill Gates and Paul Allen.")
{
Language = "en",
},
new TextDocumentInput("2", "Mi perro y mi gato tienen que ir al veterinario.")
{
Language = "es",
}
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
{
ActionName = "DisableServaiceLogsTrue", DisableServiceLogs = true
},
new ExtractKeyPhrasesAction()
{
ActionName = "DisableServiceLogsFalse"
},
},
RecognizeEntitiesActions = new List <RecognizeEntitiesAction>()
{
new RecognizeEntitiesAction()
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new RecognizeEntitiesAction()
{
ActionName = "DisableServiceLogsFalse"
},
},
RecognizePiiEntitiesActions = new List <RecognizePiiEntitiesAction>()
{
new RecognizePiiEntitiesAction()
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new RecognizePiiEntitiesAction()
{
ActionName = "DisableServiceLogsFalse"
},
},
RecognizeLinkedEntitiesActions = new List <RecognizeLinkedEntitiesAction>()
{
new RecognizeLinkedEntitiesAction()
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new RecognizeLinkedEntitiesAction()
{
ActionName = "DisableServiceLogsFalse"
},
},
AnalyzeSentimentActions = new List <AnalyzeSentimentAction>()
{
new AnalyzeSentimentAction()
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new AnalyzeSentimentAction()
{
ActionName = "DisableServiceLogsFalse"
},
},
RecognizeCustomEntitiesActions = new List <RecognizeCustomEntitiesAction>()
{
new RecognizeCustomEntitiesAction(TestEnvironment.RecognizeCustomEntitiesProjectName, TestEnvironment.RecognizeCustomEntitiesDeploymentName)
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new RecognizeCustomEntitiesAction(TestEnvironment.RecognizeCustomEntitiesProjectName, TestEnvironment.RecognizeCustomEntitiesDeploymentName)
{
ActionName = "DisableServiceLogsFalse"
},
},
SingleCategoryClassifyActions = new List <SingleCategoryClassifyAction>()
{
new SingleCategoryClassifyAction(TestEnvironment.SingleClassificationProjectName, TestEnvironment.SingleClassificationDeploymentName)
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new SingleCategoryClassifyAction(TestEnvironment.SingleClassificationProjectName, TestEnvironment.SingleClassificationDeploymentName)
{
ActionName = "DisableServiceLogsFalse"
},
},
MultiCategoryClassifyActions = new List <MultiCategoryClassifyAction>()
{
new MultiCategoryClassifyAction(TestEnvironment.MultiClassificationProjectName, TestEnvironment.MultiClassificationDeploymentName)
{
ActionName = "DisableServiceLogsTrue", DisableServiceLogs = true
},
new MultiCategoryClassifyAction(TestEnvironment.MultiClassificationProjectName, TestEnvironment.MultiClassificationDeploymentName)
{
ActionName = "DisableServiceLogsFalse"
},
},
DisplayName = "AnalyzeOperationWithMultipleTasksOfSameType"
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchDocuments, batchActions);
Assert.AreEqual(0, operation.ActionsFailed);
Assert.AreEqual(0, operation.ActionsSucceeded);
Assert.AreEqual(0, operation.ActionsInProgress);
Assert.AreEqual(0, operation.ActionsTotal);
await operation.WaitForCompletionAsync();
Assert.AreEqual(0, operation.ActionsFailed);
Assert.AreEqual(16, operation.ActionsSucceeded);
Assert.AreEqual(0, operation.ActionsInProgress);
Assert.AreEqual(16, operation.ActionsTotal);
Assert.AreNotEqual(new DateTimeOffset(), operation.CreatedOn);
Assert.AreNotEqual(new DateTimeOffset(), operation.LastModified);
Assert.AreNotEqual(new DateTimeOffset(), operation.ExpiresOn);
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizeEntitiesActionResult> entitiesActionsResults = resultCollection.RecognizeEntitiesResults;
IReadOnlyCollection <ExtractKeyPhrasesActionResult> keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesResults;
IReadOnlyCollection <RecognizePiiEntitiesActionResult> piiActionsResults = resultCollection.RecognizePiiEntitiesResults;
IReadOnlyCollection <RecognizeLinkedEntitiesActionResult> entityLinkingActionsResults = resultCollection.RecognizeLinkedEntitiesResults;
IReadOnlyCollection <AnalyzeSentimentActionResult> analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentResults;
IReadOnlyCollection <RecognizeCustomEntitiesActionResult> recognizeCustomEntitiesResults = resultCollection.RecognizeCustomEntitiesResults;
IReadOnlyCollection <SingleCategoryClassifyActionResult> singleCategoryClassifyResults = resultCollection.SingleCategoryClassifyResults;
IReadOnlyCollection <MultiCategoryClassifyActionResult> multiCategoryClassifyResults = resultCollection.MultiCategoryClassifyResults;
Assert.IsNotNull(keyPhrasesActionsResults);
Assert.IsNotNull(entitiesActionsResults);
Assert.IsNotNull(piiActionsResults);
Assert.IsNotNull(entityLinkingActionsResults);
Assert.IsNotNull(analyzeSentimentActionsResults);
Assert.IsNotNull(recognizeCustomEntitiesResults);
Assert.IsNotNull(singleCategoryClassifyResults);
Assert.IsNotNull(multiCategoryClassifyResults);
Assert.AreEqual("AnalyzeOperationWithMultipleTasks", operation.DisplayName);
}
public async Task AnalyzeOperationWithMultipleActions()
{
TextAnalyticsClient client = GetClient();
var batchDocuments = new List <TextDocumentInput>
{
new TextDocumentInput("1", "Microsoft was founded by Bill Gates and Paul Allen.")
{
Language = "en",
},
new TextDocumentInput("2", "Mi perro y mi gato tienen que ir al veterinario.")
{
Language = "es",
}
};
TextAnalyticsActions batchActions = new TextAnalyticsActions()
{
ExtractKeyPhrasesActions = new List <ExtractKeyPhrasesAction>()
{
new ExtractKeyPhrasesAction()
},
RecognizeEntitiesActions = new List <RecognizeEntitiesAction>()
{
new RecognizeEntitiesAction()
},
RecognizePiiEntitiesActions = new List <RecognizePiiEntitiesAction>()
{
new RecognizePiiEntitiesAction()
},
RecognizeLinkedEntitiesActions = new List <RecognizeLinkedEntitiesAction>()
{
new RecognizeLinkedEntitiesAction()
},
AnalyzeSentimentActions = new List <AnalyzeSentimentAction>()
{
new AnalyzeSentimentAction()
},
DisplayName = "AnalyzeOperationWithMultipleTasks"
};
AnalyzeActionsOperation operation = await client.StartAnalyzeActionsAsync(batchDocuments, batchActions);
Assert.AreEqual(0, operation.ActionsFailed);
Assert.AreEqual(0, operation.ActionsSucceeded);
Assert.AreEqual(0, operation.ActionsInProgress);
Assert.AreEqual(0, operation.ActionsTotal);
await operation.WaitForCompletionAsync();
Assert.AreEqual(0, operation.ActionsFailed);
Assert.AreEqual(5, operation.ActionsSucceeded);
Assert.AreEqual(0, operation.ActionsInProgress);
Assert.AreEqual(5, operation.ActionsTotal);
Assert.AreNotEqual(new DateTimeOffset(), operation.CreatedOn);
Assert.AreNotEqual(new DateTimeOffset(), operation.LastModified);
Assert.AreNotEqual(new DateTimeOffset(), operation.ExpiresOn);
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
IReadOnlyCollection <RecognizeEntitiesActionResult> entitiesActionsResults = resultCollection.RecognizeEntitiesActionsResults;
IReadOnlyCollection <ExtractKeyPhrasesActionResult> keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesActionsResults;
IReadOnlyCollection <RecognizePiiEntitiesActionResult> piiActionsResults = resultCollection.RecognizePiiEntitiesActionsResults;
IReadOnlyCollection <RecognizeLinkedEntitiesActionResult> entityLinkingActionsResults = resultCollection.RecognizeLinkedEntitiesActionsResults;
IReadOnlyCollection <AnalyzeSentimentActionResult> analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentActionsResults;
Assert.IsNotNull(keyPhrasesActionsResults);
Assert.IsNotNull(entitiesActionsResults);
Assert.IsNotNull(piiActionsResults);
Assert.IsNotNull(entityLinkingActionsResults);
Assert.AreEqual("AnalyzeOperationWithMultipleTasks", operation.DisplayName);
// Keyphrases
ExtractKeyPhrasesResultCollection keyPhrasesResults = keyPhrasesActionsResults.FirstOrDefault().Result;
Assert.AreEqual(2, keyPhrasesResults.Count);
var keyPhrasesListId1 = new List <string> {
"Bill Gates", "Paul Allen", "Microsoft"
};
var keyPhrasesListId2 = new List <string> {
"gato", "perro", "veterinario"
};
foreach (string keyphrase in keyPhrasesResults[0].KeyPhrases)
{
Assert.IsTrue(keyPhrasesListId1.Contains(keyphrase));
}
foreach (string keyphrase in keyPhrasesResults[1].KeyPhrases)
{
Assert.IsTrue(keyPhrasesListId2.Contains(keyphrase));
}
// Entities
RecognizeEntitiesResultCollection entitiesResult = entitiesActionsResults.FirstOrDefault().Result;
Assert.AreEqual(2, entitiesResult.Count);
Assert.AreEqual(3, entitiesResult[0].Entities.Count);
var entitiesList = new List <string> {
"Bill Gates", "Microsoft", "Paul Allen"
};
foreach (CategorizedEntity entity in entitiesResult[0].Entities)
{
Assert.IsTrue(entitiesList.Contains(entity.Text));
Assert.IsNotNull(entity.Category);
Assert.IsNotNull(entity.Offset);
Assert.IsNotNull(entity.ConfidenceScore);
}
// PII
RecognizePiiEntitiesResultCollection piiResult = piiActionsResults.FirstOrDefault().Result;
Assert.AreEqual(2, piiResult.Count);
Assert.AreEqual(3, piiResult[0].Entities.Count);
Assert.IsNotNull(piiResult[0].Id);
Assert.IsNotNull(piiResult[0].Entities);
Assert.IsNotNull(piiResult[0].Error);
// Entity Linking
RecognizeLinkedEntitiesResultCollection entityLinkingResult = entityLinkingActionsResults.FirstOrDefault().Result;
Assert.AreEqual(2, entityLinkingResult.Count);
Assert.AreEqual(3, entityLinkingResult[0].Entities.Count);
Assert.IsNotNull(entityLinkingResult[0].Id);
Assert.IsNotNull(entityLinkingResult[0].Entities);
Assert.IsNotNull(entityLinkingResult[0].Error);
foreach (LinkedEntity entity in entityLinkingResult[0].Entities)
{
if (entity.Name == "Bill Gates")
{
Assert.AreEqual("Bill Gates", entity.DataSourceEntityId);
Assert.AreEqual("Wikipedia", entity.DataSource);
}
if (entity.Name == "Microsoft")
{
Assert.AreEqual("Microsoft", entity.DataSourceEntityId);
Assert.AreEqual("Wikipedia", entity.DataSource);
}
}
// Analyze sentiment
AnalyzeSentimentResultCollection analyzeSentimentResult = analyzeSentimentActionsResults.FirstOrDefault().Result;
Assert.AreEqual(2, analyzeSentimentResult.Count);
Assert.AreEqual(TextSentiment.Neutral, analyzeSentimentResult[0].DocumentSentiment.Sentiment);
Assert.AreEqual(TextSentiment.Neutral, analyzeSentimentResult[1].DocumentSentiment.Sentiment);
}
public async Task AnalyzeOperationWithActionsError()
{
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(@"
{
""displayName"": ""AnalyzeOperationBatchWithErrorTest"",
""jobId"": ""75d521bc-c2aa-4d8a-aabe-713e72d53a2d"",
""lastUpdateDateTime"": ""2021-03-03T22:39:37Z"",
""createdDateTime"": ""2021-03-03T22:39:36Z"",
""expirationDateTime"": ""2021-03-04T22:39:36Z"",
""status"": ""succeeded"",
""errors"": [
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/entityRecognitionPiiTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/entityRecognitionTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/keyPhraseExtractionTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/entityLinkingTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/sentimentAnalysisTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/extractiveSummarizationTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/customEntityRecognitionTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/customSingleClassificationTasks/0""
},
{
""code"": ""InvalidRequest"",
""message"": ""Some error"",
""target"": ""#/tasks/customMultiClassificationTasks/0""
}
],
""tasks"": {
""details"": {
""name"": ""AnalyzeOperationBatchWithErrorTest"",
""lastUpdateDateTime"": ""2021-03-03T22:39:37Z""
},
""completed"": 0,
""failed"": 9,
""inProgress"": 0,
""total"": 9,
""entityRecognitionTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""entityRecognitionPiiTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""keyPhraseExtractionTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""entityLinkingTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""sentimentAnalysisTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""extractiveSummarizationTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""customEntityRecognitionTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""customSingleClassificationTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
],
""customMultiClassificationTasks"": [
{
""lastUpdateDateTime"": ""2021-03-03T22:39:37.1716697Z"",
""taskName"": ""something"",
""state"": ""failed""
}
]
}
}"));
var mockResponse = new MockResponse(200);
mockResponse.ContentStream = stream;
var mockTransport = new MockTransport(new[] { mockResponse });
var client = CreateTestClient(mockTransport);
AnalyzeActionsOperation operation = CreateOperation(client);
await operation.UpdateStatusAsync();
Assert.AreEqual(9, operation.ActionsFailed);
Assert.AreEqual(0, operation.ActionsSucceeded);
Assert.AreEqual(0, operation.ActionsInProgress);
Assert.AreEqual(9, operation.ActionsTotal);
//Take the first page
AnalyzeActionsResult resultCollection = operation.Value.ToEnumerableAsync().Result.FirstOrDefault();
RecognizeEntitiesActionResult entitiesActionsResults = resultCollection.RecognizeEntitiesResults.FirstOrDefault();
ExtractKeyPhrasesActionResult keyPhrasesActionsResults = resultCollection.ExtractKeyPhrasesResults.FirstOrDefault();
RecognizePiiEntitiesActionResult piiActionsResults = resultCollection.RecognizePiiEntitiesResults.FirstOrDefault();
RecognizeLinkedEntitiesActionResult entityLinkingActionsResults = resultCollection.RecognizeLinkedEntitiesResults.FirstOrDefault();
AnalyzeSentimentActionResult analyzeSentimentActionsResults = resultCollection.AnalyzeSentimentResults.FirstOrDefault();
ExtractSummaryActionResult extractSummaryActionsResults = resultCollection.ExtractSummaryResults.FirstOrDefault();
RecognizeCustomEntitiesActionResult recognizeCustomEntitiesActionResults = resultCollection.RecognizeCustomEntitiesResults.FirstOrDefault();
SingleCategoryClassifyActionResult singleCategoryClassifyActionResult = resultCollection.SingleCategoryClassifyResults.FirstOrDefault();
MultiCategoryClassifyActionResult multiCategoryClassifyActionResult = resultCollection.MultiCategoryClassifyResults.FirstOrDefault();
Assert.IsTrue(entitiesActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => entitiesActionsResults.DocumentsResults.GetType());
Assert.IsTrue(keyPhrasesActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => keyPhrasesActionsResults.DocumentsResults.GetType());
Assert.IsTrue(piiActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => piiActionsResults.DocumentsResults.GetType());
Assert.IsTrue(entityLinkingActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => entityLinkingActionsResults.DocumentsResults.GetType());
Assert.IsTrue(analyzeSentimentActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => analyzeSentimentActionsResults.DocumentsResults.GetType());
Assert.IsTrue(extractSummaryActionsResults.HasError);
Assert.Throws <InvalidOperationException>(() => extractSummaryActionsResults.DocumentsResults.GetType());
Assert.IsTrue(recognizeCustomEntitiesActionResults.HasError);
Assert.Throws <InvalidOperationException>(() => recognizeCustomEntitiesActionResults.DocumentsResults.GetType());
Assert.IsTrue(singleCategoryClassifyActionResult.HasError);
Assert.Throws <InvalidOperationException>(() => singleCategoryClassifyActionResult.DocumentsResults.GetType());
Assert.IsTrue(multiCategoryClassifyActionResult.HasError);
Assert.Throws <InvalidOperationException>(() => multiCategoryClassifyActionResult.DocumentsResults.GetType());
}
