public async Task AnalyzeSentimentWithOpinionMining()
{
TextAnalyticsClient client = GetClient();
string document = "The park was clean and pretty. The bathrooms and restaurant were not clean.";
DocumentSentiment docSentiment = await client.AnalyzeSentimentAsync(document, options : new AnalyzeSentimentOptions()
{
IncludeOpinionMining = true
});
CheckAnalyzeSentimentProperties(docSentiment, opinionMining: true);
Assert.AreEqual("Mixed", docSentiment.Sentiment.ToString());
}
public async Task AnalyzeSentimentWithOpinionMiningEmpty()
{
TextAnalyticsClient client = GetClient();
string document = singleEnglish;
DocumentSentiment docSentiment = await client.AnalyzeSentimentAsync(document, "en", new AnalyzeSentimentOptions()
{
IncludeOpinionMining = true
});
CheckAnalyzeSentimentProperties(docSentiment);
Assert.AreEqual("Positive", docSentiment.Sentiment.ToString());
}
public async Task <AzTextAnalyticsResult> AnalyzeText(string textToAnalyze)
{
var endpoint = new Uri(_analyticsUrl);
var key = _analyticsKey;
var client = new TextAnalyticsClient(endpoint, new TextAnalyticsApiKeyCredential(key));
var response = await client.AnalyzeSentimentAsync(textToAnalyze);
var textAnalyticsResult = _mapper.Map <DocumentSentiment, AzTextAnalyticsResult>(response.Value);
textAnalyticsResult.TextAnalyzed = textToAnalyze;
return(textAnalyticsResult);
}
public async Task <Sentiment> AnalysisAsync(string message)
{
var client = new TextAnalyticsClient(new Uri(this.appSetting.TextAnalyticsEndpoint), new AzureKeyCredential(this.appSetting.TextAnalyticsApiKey));
var documentSentiment = await client.AnalyzeSentimentAsync(message);
return(new Sentiment()
{
Positive = documentSentiment.Value.ConfidenceScores.Positive,
Negative = documentSentiment.Value.ConfidenceScores.Negative,
Neutral = documentSentiment.Value.ConfidenceScores.Neutral,
Message = message
});
}
public async Task AnalyzeSentimentTest()
{
TextAnalyticsClient client = GetClient();
string input = "That was the best day of my life!";
AnalyzeSentimentResult result = await client.AnalyzeSentimentAsync(input);
TextSentiment sentiment = result.DocumentSentiment;
Assert.AreEqual("Positive", sentiment.SentimentClass.ToString());
Assert.IsNotNull(sentiment.PositiveScore);
Assert.IsNotNull(sentiment.NeutralScore);
Assert.IsNotNull(sentiment.NegativeScore);
Assert.IsNotNull(sentiment.Offset);
}
public static async Task TestTextAnalyticsApiKeyAsync(string key, string apiEndpoint)
{
bool isUri = !string.IsNullOrEmpty(apiEndpoint) ? Uri.IsWellFormedUriString(apiEndpoint, UriKind.Absolute) : false;
if (!isUri)
{
throw new ArgumentException("Invalid URI");
}
else
{
var credentials = new AzureKeyCredential(key);
var endpoint = new Uri(apiEndpoint);
TextAnalyticsClient client = new TextAnalyticsClient(endpoint, credentials);
await client.AnalyzeSentimentAsync("I had the best day of my life.");
}
}
static async Task Analyze(TextAnalyticsClient client, string text)
{
DocumentSentiment sentiment = await client.AnalyzeSentimentAsync(text);
Console.WriteLine($"Sentiment: {sentiment.ConfidenceScores.Positive}:{sentiment.ConfidenceScores.Neutral}:{sentiment.ConfidenceScores.Negative} - {sentiment.Sentiment}");
var keywords = await client.ExtractKeyPhrasesAsync(text);
// Printing key phrases
Console.WriteLine("Key phrases:");
foreach (string keyphrase in keywords.Value)
{
Console.WriteLine($"\t{keyphrase}");
}
}
public async Task AnalyzeSentimentAsync()
{
string endpoint = Environment.GetEnvironmentVariable("TEXT_ANALYTICS_ENDPOINT");
string apiKey = Environment.GetEnvironmentVariable("TEXT_ANALYTICS_API_KEY");
var client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
string document = "That was the best day of my life!";
DocumentSentiment docSentiment = await client.AnalyzeSentimentAsync(document);
Console.WriteLine($"Sentiment was {docSentiment.Sentiment}, with confidence scores: ");
Console.WriteLine($" Positive confidence score: {docSentiment.ConfidenceScores.Positive}.");
Console.WriteLine($" Neutral confidence score: {docSentiment.ConfidenceScores.Neutral}.");
Console.WriteLine($" Negative confidence score: {docSentiment.ConfidenceScores.Negative}.");
}
public async Task <CognitiveServicesModel> AccessCognitiveServices(string input)
{
Azure.Response <DocumentSentiment> response =
await _textAnalyticsClient.AnalyzeSentimentAsync(input);
DocumentSentiment sentiment = response.Value;
return(new CognitiveServicesModel
{
Sentiment = sentiment.Sentiment.ToString(),
ConfidenceScores = new Dictionary <string, double>
{
[TextSentiment.Positive.ToString()] = sentiment.ConfidenceScores.Positive,
[TextSentiment.Negative.ToString()] = sentiment.ConfidenceScores.Negative,
[TextSentiment.Neutral.ToString()] = sentiment.ConfidenceScores.Neutral,
}
});
}
public async Task DoSentimentAnalysis(string message)
{
DocumentSentiment documentSentiment = await _client.AnalyzeSentimentAsync(message);
Console.WriteLine($"Document sentiment: { documentSentiment.Sentiment }\n");
var stringInfo = new StringInfo(message);
foreach (var sentence in documentSentiment.Sentences)
{
Console.WriteLine($"\tSentence [length {sentence.GraphemeLength}]");
Console.WriteLine($"\tText: \"{stringInfo.SubstringByTextElements(sentence.GraphemeOffset, sentence.GraphemeLength)}\"");
Console.WriteLine($"\tSentence sentiment: {sentence.Sentiment}");
Console.WriteLine($"\tPositive score: {sentence.ConfidenceScores.Positive:0.00}");
Console.WriteLine($"\tNegative score: {sentence.ConfidenceScores.Negative:0.00}");
Console.WriteLine($"\tNeutral score: {sentence.ConfidenceScores.Neutral:0.00}\n");
}
}
public async Task AnalyzeSentimentWithOpinionMiningNegated()
{
TextAnalyticsClient client = GetClient();
string document = "The bathrooms are not clean.";
DocumentSentiment docSentiment = await client.AnalyzeSentimentAsync(document, options : new AnalyzeSentimentOptions()
{
IncludeOpinionMining = true
});
CheckAnalyzeSentimentProperties(docSentiment, opinionMining: true);
SentenceOpinion opinion = docSentiment.Sentences.FirstOrDefault().Opinions.FirstOrDefault();
Assert.AreEqual("bathrooms", opinion.Target.Text);
Assert.AreEqual(TextSentiment.Negative, opinion.Target.Sentiment);
Assert.AreEqual("clean", opinion.Assessments.FirstOrDefault().Text);
Assert.AreEqual(TextSentiment.Negative, opinion.Assessments.FirstOrDefault().Sentiment);
Assert.IsTrue(opinion.Assessments.FirstOrDefault().IsNegated);
}
public async Task AnalyzeSentimentWithOpinionMiningNegated()
{
TextAnalyticsClient client = GetClient();
string document = "The bathrooms are not clean.";
DocumentSentiment docSentiment = await client.AnalyzeSentimentAsync(document, options : new AnalyzeSentimentOptions()
{
AdditionalSentimentAnalyses = AdditionalSentimentAnalyses.OpinionMining
});
CheckAnalyzeSentimentProperties(docSentiment, opinionMining: true);
MinedOpinion minedOpinion = docSentiment.Sentences.FirstOrDefault().MinedOpinions.FirstOrDefault();
Assert.AreEqual("bathrooms", minedOpinion.Aspect.Text);
Assert.AreEqual(TextSentiment.Negative, minedOpinion.Aspect.Sentiment);
Assert.AreEqual("clean", minedOpinion.Opinions.FirstOrDefault().Text);
Assert.AreEqual(TextSentiment.Negative, minedOpinion.Opinions.FirstOrDefault().Sentiment);
Assert.IsTrue(minedOpinion.Opinions.FirstOrDefault().IsNegated);
}
private static async Task SentimentAnalysisExampleAsync(TextAnalyticsClient client)
{
WriteLine("****** Sentiment analysis ******");
WriteLine();
var document = "I had the best day of my life. I wish you were there with me.";
DocumentSentiment documentSentiment = await client.AnalyzeSentimentAsync(document);
WriteLine($"Document: {document}");
WriteLine($"Document sentiment: {documentSentiment.Sentiment}\n");
foreach (var sentence in documentSentiment.Sentences)
{
WriteLine($"\tText: \"{sentence.Text}\"");
WriteLine($"\tSentence sentiment: {sentence.Sentiment}");
WriteLine($"\tPositive score: {sentence.ConfidenceScores.Positive:0.00}");
WriteLine($"\tNegative score: {sentence.ConfidenceScores.Negative:0.00}");
WriteLine($"\tNeutral score: {sentence.ConfidenceScores.Neutral:0.00}\n");
}
WriteLine();
}
public async Task <FileAnalysisResult> AnalyzeFileContentAsync(InputFileData inputFileData)
{
if (inputFileData.FileContentType == FileContentType.PDF)
{
var sasToken = _storageService.GenerateSasToken();
inputFileData.FilePath = $"{inputFileData.FilePath}?{sasToken}";
var textFromTheInputDocument = await _ocrScannerService.ScanDocumentAndGetResultsAsync(inputFileData.FilePath);
var sentimentAnalysisResponse = await _textAnalyticsClient.AnalyzeSentimentAsync(textFromTheInputDocument);
if (sentimentAnalysisResponse != null)
{
var sentimentAnalysisResult = sentimentAnalysisResponse.Value;
var fileAnalysisResult = new FileAnalysisResult();
fileAnalysisResult.SentimentValues.Add(sentimentAnalysisResult.Sentiment.ToString());
return(fileAnalysisResult);
}
}
throw new ArgumentException("Input file shuld be either TXT or PDF file.");
}
public async Task AnalyzeSentimentTest()
{
TextAnalyticsClient client = GetClient();
string document = "That was the best day of my life!";
DocumentSentiment docSentiment = await client.AnalyzeSentimentAsync(document);
Assert.AreEqual("Positive", docSentiment.Sentiment.ToString());
Assert.IsNotNull(docSentiment.ConfidenceScores.Positive);
Assert.IsNotNull(docSentiment.ConfidenceScores.Neutral);
Assert.IsNotNull(docSentiment.ConfidenceScores.Negative);
foreach (var sentence in docSentiment.Sentences)
{
Assert.AreEqual("Positive", sentence.Sentiment.ToString());
Assert.IsNotNull(sentence.Text);
Assert.AreEqual(document, sentence.Text);
Assert.IsNotNull(sentence.ConfidenceScores.Positive);
Assert.IsNotNull(sentence.ConfidenceScores.Neutral);
Assert.IsNotNull(sentence.ConfidenceScores.Negative);
}
}
public async Task <DocumentSentiment> AnalyzeSentitmentAsync(string text, string language = "en")
{
DocumentSentiment result = await client.AnalyzeSentimentAsync(text, language);
return(result);
}
static async Task Main(string[] args)
{
Env.Load("../../../../.env");
//using var listener = AzureEventSourceListener.CreateConsoleLogger();
var cred = Identity.GetCredentialChain();
// QueueClient
var queueServiceClient = new QueueServiceClient(
new Uri(Env.GetString("AZURE_STORAGE_QUEUE_ENDPOINT")), cred);
var queueClient = queueServiceClient.GetQueueClient(Env.GetString("AZURE_STORAGE_QUEUE_NAME"));
await queueClient.CreateIfNotExistsAsync();
// FormRecognizerClient
var formRecognizerClient = new FormRecognizerClient(
new Uri(Env.GetString("AZURE_FORM_RECOGNIZER_ENDPOINT")),
cred);
// TextAnalyticsClient
var textAnalyticsClient = new TextAnalyticsClient(
new Uri(Env.GetString("AZURE_TEXT_ANALYTICS_ENDPOINT")),
cred);
// CosmosClient
var cosmosClient = new CosmosClient(
Env.GetString("AZURE_COSMOS_ENDPOINT"),
Env.GetString("AZURE_COSMOS_KEY"),
new CosmosClientOptions
{
Diagnostics =
{
IsLoggingEnabled = false
},
ConnectionMode = ConnectionMode.Direct,
ConsistencyLevel = ConsistencyLevel.Session,
SerializerOptions = new CosmosSerializationOptions {
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase, IgnoreNullValues = true
},
});
// Create Database and Container
var databaseResponse = await cosmosClient.CreateDatabaseIfNotExistsAsync(Env.GetString("AZURE_COSMOS_DB"));
var containerResponse = await databaseResponse.Database.CreateContainerIfNotExistsAsync(new ContainerProperties(Env.GetString("AZURE_COSMOS_CONTAINER"), "/uid"));
while (true)
{
Console.WriteLine("Receiving Messages...");
// Get Messages
var messages = await queueClient.ReceiveMessagesAsync(maxMessages : Env.GetInt("AZURE_STORAGE_QUEUE_MSG_COUNT", 10));
foreach (var message in messages.Value)
{
Console.WriteLine(message.MessageText);
// Deserialize Message
var image = JsonSerializer.Deserialize <Image>(message.MessageText,
new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
// Extract Text from Image
var recognizeContentOperation = await formRecognizerClient.StartRecognizeContentFromUriAsync(new Uri(image.BlobUri));
var recognizeContentCompletion = await recognizeContentOperation.WaitForCompletionAsync();
var content = recognizeContentCompletion.Value;
var text = content.SelectMany(page => page.Lines).Aggregate(new StringBuilder(), (a, b) =>
{
a.Append($"{b.Text} ");
return(a);
});
image.Text = text.ToString();
if (!string.IsNullOrEmpty(image.Text))
{
Console.WriteLine($"Image Text: {image.Text}");
// Analyize Text Sentiment
var documentSentiment = await textAnalyticsClient.AnalyzeSentimentAsync(image.Text);
image.Sentiment = documentSentiment.Value.Sentiment.ToString();
Console.WriteLine($"Image Sentiment: {image.Sentiment}");
}
else
{
Console.WriteLine("No Text Extracted from Image.");
}
// Create Cosmos Document
var document = await containerResponse.Container.UpsertItemAsync(image);
Console.WriteLine($"Cosmos Document Saved: {document.Value.Id}");
// Delete Queue Message
var deleteResponse = await queueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
Console.WriteLine($"Queue Message Deleted: {message.MessageId}");
}
await Task.Delay(TimeSpan.FromSeconds(Env.GetInt("AZURE_STORAGE_QUEUE_RECEIVE_SLEEP", 1)));
}
}
public async Task <string> AnalyseSentiment(string textToAnalyse)
{
DocumentSentiment documentSentiment = await client.AnalyzeSentimentAsync(textToAnalyse);
return(documentSentiment.Sentiment.ToString());
}
private static async Task <TextSentiment> GetSentiment(string text)
{
DocumentSentiment documentSentiment = await client.AnalyzeSentimentAsync(text);
return(documentSentiment.Sentiment);
}
