async def test_bad_document_input_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = "This is the wrong type"
with self.assertRaises(TypeError):
response = await text_analytics.analyze_sentiment(docs)
async def recognize_linked_entities_async(self):
# [START batch_recognize_linked_entities_async]
from azure.cognitiveservices.language.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint,
credential=self.key)
documents = [
"Microsoft moved its headquarters to Bellevue, Washington in January 1979.",
"Steve Ballmer stepped down as CEO of Microsoft and was succeeded by Satya Nadella.",
"Microsoft superó a Apple Inc. como la compañía más valiosa que cotiza en bolsa en el mundo.",
]
async with text_analytics_client:
result = await text_analytics_client.recognize_linked_entities(
documents)
docs = [doc for doc in result if not doc.is_error]
for idx, doc in enumerate(docs):
print("Document text: {}\n".format(documents[idx]))
for entity in doc.entities:
print("Entity: {}".format(entity.name))
print("Url: {}".format(entity.url))
print("Data Source: {}".format(entity.data_source))
for match in entity.matches:
print("Score: {0:.3f}".format(match.score))
print("Offset: {}".format(match.offset))
print("Length: {}\n".format(match.length))
print("------------------------------------------")
async def detect_languages_async(self):
# [START batch_detect_languages_async]
from azure.cognitiveservices.language.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint,
credential=self.key)
documents = [
"This document is written in English.",
"Este es un document escrito en Español.", "这是一个用中文写的文件",
"Dies ist ein Dokument in englischer Sprache.",
"Detta är ett dokument skrivet på engelska."
]
async with text_analytics_client:
result = await text_analytics_client.detect_languages(documents)
for idx, doc in enumerate(result):
if not doc.is_error:
print("Document text: {}".format(documents[idx]))
print("Language detected: {}".format(
doc.detected_languages[0].name))
print("ISO6391 name: {}".format(
doc.detected_languages[0].iso6391_name))
print("Confidence score: {}\n".format(
doc.detected_languages[0].score))
if doc.is_error:
print(doc.id, doc.error)
async def test_successful_recognize_linked_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "en", "text": "Microsoft was founded by Bill Gates and Paul Allen"},
{"id": "2", "language": "es", "text": "Microsoft fue fundado por Bill Gates y Paul Allen"}]
response = await text_analytics.recognize_linked_entities(docs)
for doc in response:
self.assertEqual(len(doc.entities), 3)
async def test_all_errors_recognize_pii_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "es", "text": "hola"},
{"id": "2", "text": ""}]
response = await text_analytics.recognize_pii_entities(docs)
self.assertTrue(response[0].is_error)
self.assertTrue(response[1].is_error)
async def test_all_errors_recognize_linked_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "text": ""},
{"id": "2", "language": "Spanish", "text": "Microsoft fue fundado por Bill Gates y Paul Allen"}]
response = await text_analytics.recognize_linked_entities(docs)
self.assertTrue(response[0].is_error)
self.assertTrue(response[1].is_error)
async def test_all_errors_extract_key_phrases_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "English", "text": "Microsoft was founded by Bill Gates and Paul Allen"},
{"id": "2", "language": "es", "text": ""}]
response = await text_analytics.extract_key_phrases(docs)
self.assertTrue(response[0].is_error)
self.assertTrue(response[1].is_error)
async def test_mixing_inputs_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [
{"id": "1", "text": "Microsoft was founded by Bill Gates and Paul Allen."},
TextDocumentInput(id="2", text="I did not like the hotel we stayed it. It was too expensive."),
"You cannot mix string input with the above inputs"
]
with self.assertRaises(TypeError):
response = await text_analytics.analyze_sentiment(docs)
async def test_successful_recognize_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "en", "text": "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975."},
{"id": "2", "language": "es", "text": "Microsoft fue fundado por Bill Gates y Paul Allen el 4 de abril de 1975."},
{"id": "3", "language": "de", "text": "Microsoft wurde am 4. April 1975 von Bill Gates und Paul Allen gegründet."}]
response = await text_analytics.recognize_entities(docs)
for doc in response:
self.assertEqual(len(doc.entities), 4)
async def test_some_errors_analyze_sentiment_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "en", "text": ""},
{"id": "2", "language": "english", "text": "I did not like the hotel we stayed it. It was too expensive."},
{"id": "3", "language": "en", "text": "The restaurant had really good food. I recommend you try it."}]
response = await text_analytics.analyze_sentiment(docs)
self.assertTrue(response[0].is_error)
self.assertTrue(response[1].is_error)
async def test_some_errors_recognize_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "en", "text": "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975."},
{"id": "2", "language": "Spanish", "text": "Hola"},
{"id": "3", "language": "de", "text": ""}]
response = await text_analytics.recognize_entities(docs)
self.assertFalse(response[0].is_error)
self.assertTrue(response[1].is_error)
self.assertTrue(response[2].is_error)
async def test_active_directory_auth_async(self):
token = self.generate_oauth_token()
endpoint = self.get_oauth_endpoint()
text_analytics = TextAnalyticsClient(endpoint, token)
docs = [{"id": "1", "text": "I should take my cat to the veterinarian."},
{"id": "2", "text": "Este es un document escrito en Español."},
{"id": "3", "text": "猫は幸せ"},
{"id": "4", "text": "Fahrt nach Stuttgart und dann zum Hotel zu Fu."}]
response = await text_analytics.detect_languages(docs)
async def test_successful_analyze_sentiment_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "en", "text": "Microsoft was founded by Bill Gates and Paul Allen."},
{"id": "2", "language": "en", "text": "I did not like the hotel we stayed it. It was too expensive."},
{"id": "3", "language": "en", "text": "The restaurant had really good food. I recommend you try it."}]
response = await text_analytics.analyze_sentiment(docs)
self.assertEqual(response[0].sentiment, "neutral")
self.assertEqual(response[1].sentiment, "negative")
self.assertEqual(response[2].sentiment, "positive")
async def test_some_errors_recognize_pii_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "es", "text": "hola"},
{"id": "2", "text": ""},
{"id": "3", "text": "Is 998.214.865-68 your Brazilian CPF number?"}]
response = await text_analytics.recognize_pii_entities(docs)
self.assertTrue(response[0].is_error)
self.assertTrue(response[1].is_error)
self.assertFalse(response[2].is_error)
async def test_successful_extract_key_phrases_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "language": "en", "text": "Microsoft was founded by Bill Gates and Paul Allen"},
{"id": "2", "language": "es", "text": "Microsoft fue fundado por Bill Gates y Paul Allen"}]
response = await text_analytics.extract_key_phrases(docs)
for phrases in response:
self.assertIn("Paul Allen", phrases.key_phrases)
self.assertIn("Bill Gates", phrases.key_phrases)
self.assertIn("Microsoft", phrases.key_phrases)
async def alternative_scenario_recognize_linked_entities_async(self):
"""This sample demonstrates how to retrieve batch statistics, the
model version used, and the raw response returned from the service.
It additionally shows an alternative way to pass in the input documents
using a list[TextDocumentInput] and supplying your own IDs and language hints along
with the text.
"""
from azure.cognitiveservices.language.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint,
credential=self.key)
documents = [
{
"id":
"0",
"language":
"en",
"text":
"Microsoft moved its headquarters to Bellevue, Washington in January 1979."
},
{
"id":
"1",
"language":
"en",
"text":
"Steve Ballmer stepped down as CEO of Microsoft and was succeeded by Satya Nadella."
},
{
"id":
"2",
"language":
"es",
"text":
"Microsoft superó a Apple Inc. como la compañía más valiosa que cotiza en bolsa en el mundo."
},
]
extras = []
def callback(resp):
extras.append(resp.statistics)
extras.append(resp.model_version)
extras.append(resp.raw_response)
async with text_analytics_client:
result = await text_analytics_client.recognize_linked_entities(
documents,
show_stats=True,
model_version="latest",
response_hook=callback)
async def test_validate_multilanguage_input_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [
TextDocumentInput(id="1", text="Microsoft was founded by Bill Gates and Paul Allen."),
TextDocumentInput(id="2", text="I did not like the hotel we stayed it. It was too expensive."),
TextDocumentInput(id="3", text="The restaurant had really good food. I recommend you try it."),
]
response = await text_analytics.analyze_sentiment(docs)
self.assertEqual(response[0].sentiment, "neutral")
self.assertEqual(response[1].sentiment, "negative")
self.assertEqual(response[2].sentiment, "positive")
async def test_out_of_order_ids_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "56", "text": ":)"},
{"id": "0", "text": ":("},
{"id": "22", "text": ""},
{"id": "19", "text": ":P"},
{"id": "1", "text": ":D"}]
response = await text_analytics.analyze_sentiment(docs)
in_order = ["56", "0", "22", "19", "1"]
for idx, resp in enumerate(response):
self.assertEqual(resp.id, in_order[idx])
async def test_whole_batch_language_hint_and_dict_input_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
def callback(resp):
language_str = "\"language\": \"es\""
language = resp.http_request.body.count(language_str)
self.assertEqual(language, 3)
docs = [{"id": "1", "text": "I will go to the park."},
{"id": "2", "text": "I did not like the hotel we stayed it."},
{"id": "3", "text": "The restaurant had really good food."}]
response = await text_analytics.analyze_sentiment(docs, language="es", response_hook=callback)
async def test_successful_recognize_pii_entities_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "text": "My SSN is 555-55-5555."},
{"id": "2", "text": "Your ABA number - 111000025 - is the first 9 digits in the lower left hand corner of your personal check."},
{"id": "3", "text": "Is 998.214.865-68 your Brazilian CPF number?"}]
response = await text_analytics.recognize_pii_entities(docs)
self.assertEqual(response[0].entities[0].text, "555-55-5555")
self.assertEqual(response[0].entities[0].type, "U.S. Social Security Number (SSN)")
self.assertEqual(response[1].entities[0].text, "111000025")
self.assertEqual(response[1].entities[0].type, "ABA Routing Number")
self.assertEqual(response[2].entities[0].text, "998.214.865-68")
self.assertEqual(response[2].entities[0].type, "Brazil CPF Number")
async def test_successful_detect_language_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "text": "I should take my cat to the veterinarian."},
{"id": "2", "text": "Este es un document escrito en Español."},
{"id": "3", "text": "猫は幸せ"},
{"id": "4", "text": "Fahrt nach Stuttgart und dann zum Hotel zu Fu."}]
response = await text_analytics.detect_languages(docs)
self.assertEqual(response[0].detected_languages[0].name, "English")
self.assertEqual(response[1].detected_languages[0].name, "Spanish")
self.assertEqual(response[2].detected_languages[0].name, "Japanese")
self.assertEqual(response[3].detected_languages[0].name, "German")
async def test_some_errors_detect_language_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [{"id": "1", "country_hint": "United States", "text": "I should take my cat to the veterinarian."},
{"id": "2", "text": "Este es un document escrito en Español."},
{"id": "3", "text": ""},
{"id": "4", "text": "Fahrt nach Stuttgart und dann zum Hotel zu Fu."}]
response = await text_analytics.detect_languages(docs)
self.assertTrue(response[0].is_error)
self.assertFalse(response[1].is_error)
self.assertTrue(response[2].is_error)
self.assertFalse(response[3].is_error)
async def alternative_scenario_analyze_sentiment_async(self):
"""This sample demonstrates how to retrieve batch statistics, the
model version used, and the raw response returned from the service.
It additionally shows an alternative way to pass in the input documents
using a list[TextDocumentInput] and supplying your own IDs and language hints along
with the text.
"""
from azure.cognitiveservices.language.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint,
credential=self.key)
documents = [{
"id": "0",
"language": "en",
"text": "I had the best day of my life."
}, {
"id":
"1",
"language":
"en",
"text":
"This was a waste of my time. The speaker put me to sleep."
}, {
"id": "2",
"language": "es",
"text": "No tengo dinero ni nada que dar..."
}, {
"id":
"3",
"language":
"fr",
"text":
"L'hôtel n'était pas très confortable. L'éclairage était trop sombre."
}]
extras = []
def callback(resp):
extras.append(resp.statistics)
extras.append(resp.model_version)
extras.append(resp.raw_response)
async with text_analytics_client:
result = await text_analytics_client.analyze_sentiment(
documents,
show_stats=True,
model_version="latest",
response_hook=callback)
async def test_validate_language_input_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
docs = [
DetectLanguageInput(id="1", text="I should take my cat to the veterinarian."),
DetectLanguageInput(id="2", text="Este es un document escrito en Español."),
DetectLanguageInput(id="3", text="猫は幸せ"),
DetectLanguageInput(id="4", text="Fahrt nach Stuttgart und dann zum Hotel zu Fu.")
]
response = await text_analytics.detect_languages(docs)
self.assertEqual(response[0].detected_languages[0].name, "English")
self.assertEqual(response[1].detected_languages[0].name, "Spanish")
self.assertEqual(response[2].detected_languages[0].name, "Japanese")
self.assertEqual(response[3].detected_languages[0].name, "German")
async def test_whole_batch_country_hint_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
def callback(resp):
country_str = "\"countryHint\": \"CA\""
country = resp.http_request.body.count(country_str)
self.assertEqual(country, 3)
docs = [
u"This was the best day of my life.",
u"I did not like the hotel we stayed it. It was too expensive.",
u"The restaurant was not as good as I hoped."
]
response = await text_analytics.detect_languages(docs, country_hint="CA", response_hook=callback)
async def test_all_errors_detect_language_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
text = ""
for _ in range(5121):
text += "x"
docs = [{"id": "1", "text": ""},
{"id": "2", "text": ""},
{"id": "3", "text": ""},
{"id": "4", "text": text}]
response = await text_analytics.detect_languages(docs)
for resp in response:
self.assertTrue(resp.is_error)
async def test_whole_batch_language_hint_and_obj_input_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
def callback(resp):
language_str = "\"language\": \"de\""
language = resp.http_request.body.count(language_str)
self.assertEqual(language, 3)
docs = [
TextDocumentInput(id="1", text="I should take my cat to the veterinarian."),
TextDocumentInput(id="2", text="Este es un document escrito en Español."),
TextDocumentInput(id="3", text="猫は幸せ"),
]
response = await text_analytics.analyze_sentiment(docs, language="de", response_hook=callback)
async def test_whole_batch_dont_use_language_hint_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
def callback(resp):
language_str = "\"language\": \"\""
language = resp.http_request.body.count(language_str)
self.assertEqual(language, 3)
docs = [
u"This was the best day of my life.",
u"I did not like the hotel we stayed it. It was too expensive.",
u"The restaurant was not as good as I hoped."
]
response = await text_analytics.analyze_sentiment(docs, language="", response_hook=callback)
async def test_whole_batch_country_hint_and_obj_input_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
def callback(resp):
country_str = "\"countryHint\": \"CA\""
country = resp.http_request.body.count(country_str)
self.assertEqual(country, 3)
docs = [
DetectLanguageInput(id="1", text="I should take my cat to the veterinarian."),
DetectLanguageInput(id="2", text="Este es un document escrito en Español."),
DetectLanguageInput(id="3", text="猫は幸せ"),
]
response = await text_analytics.detect_languages(docs, country_hint="CA", response_hook=callback)
async def test_whole_batch_country_hint_and_dict_per_item_hints_async(self, resource_group, location, cognitiveservices_account, cognitiveservices_account_key):
text_analytics = TextAnalyticsClient(cognitiveservices_account, cognitiveservices_account_key)
def callback(resp):
country_str = "\"countryHint\": \"CA\""
country = resp.http_request.body.count(country_str)
self.assertEqual(country, 1)
country_str = "\"countryHint\": \"US\""
country = resp.http_request.body.count(country_str)
self.assertEqual(country, 2)
docs = [{"id": "1", "country_hint": "US", "text": "I will go to the park."},
{"id": "2", "country_hint": "US", "text": "I did not like the hotel we stayed it."},
{"id": "3", "text": "The restaurant had really good food."}]
response = await text_analytics.detect_languages(docs, country_hint="CA", response_hook=callback)
