azure.ai.textanalytics.aio package¶

class azure.ai.textanalytics.aio.TextAnalyticsClient(endpoint, credential, **kwargs)[source]¶

The Text Analytics API is a suite of text analytics web services built with best-in-class Microsoft machine learning algorithms. The API can be used to analyze unstructured text for tasks such as sentiment analysis, key phrase extraction, and language detection. No training data is needed to use this API - just bring your text data. This API uses advanced natural language processing techniques to deliver best in class predictions.

Further documentation can be found in https://docs.microsoft.com/azure/cognitive-services/text-analytics/overview

Parameters

endpoint (str) – Supported Cognitive Services or Text Analytics resource endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services/text analytics subscription key or a token credential from azure.identity.

Keyword Arguments

default_country_hint (str) – Sets the default country_hint to use for all operations. Defaults to “US”. If you don’t want to use a country hint, pass the empty string “”.
default_language (str) – Sets the default language to use for all operations. Defaults to “en”.

Example:

Creating the TextAnalyticsClient with endpoint and subscription key.¶

from azure.ai.textanalytics.aio import TextAnalyticsClient
endpoint = os.getenv("AZURE_TEXT_ANALYTICS_ENDPOINT")
key = os.getenv("AZURE_TEXT_ANALYTICS_KEY")

text_analytics_client = TextAnalyticsClient(endpoint, key)

Creating the TextAnalyticsClient with endpoint and token credential from Azure Active Directory.¶

from azure.ai.textanalytics.aio import TextAnalyticsClient
from azure.identity.aio import DefaultAzureCredential

endpoint = os.getenv("AZURE_TEXT_ANALYTICS_ENDPOINT")
credential = DefaultAzureCredential()

text_analytics_client = TextAnalyticsClient(endpoint, credential=credential)

async analyze_sentiment(inputs: Union[List[str], List[azure.ai.textanalytics._models.TextDocumentInput], List[Dict[str, str]]], language: Optional[str] = None, **kwargs: Any) → List[Union[azure.ai.textanalytics._models.AnalyzeSentimentResult, azure.ai.textanalytics._models.DocumentError]][source]¶

Analyze sentiment for a batch of documents.

Returns a sentiment prediction, as well as sentiment scores for each sentiment class (Positive, Negative, and Neutral) for the document and each sentence within it. See https://aka.ms/talangs for the list of enabled languages.

Parameters

inputs (list[str] or list[TextDocumentInput]) – The set of documents to process as part of this batch. If you wish to specify the ID and language on a per-item basis you must use as input a list[TextDocumentInput] or a list of dict representations of TextDocumentInput, like {“id”: “1”, “language”: “en”, “text”: “hello world”}.
language (str) – The 2 letter ISO 639-1 representation of language for the entire batch. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default. Per-document language will take precedence over whole batch language.

Keyword Arguments

model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.
show_stats (bool) – If set to true, response will contain document level statistics.

Returns

The combined list of AnalyzeSentimentResults and DocumentErrors in the order the original documents were passed in.

Return type

list[AnalyzeSentimentResult, DocumentError]

Raises

HttpResponseError –

Example:

Analyze sentiment in a batch of documents.¶

from azure.ai.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint, credential=self.key)
documents = [
    "I had the best day of my life.",
    "This was a waste of my time. The speaker put me to sleep.",
    "No tengo dinero ni nada que dar...",
    "L'hôtel n'était pas très confortable. L'éclairage était trop sombre."
]

async with text_analytics_client:
    result = await text_analytics_client.analyze_sentiment(documents)

docs = [doc for doc in result if not doc.is_error]

for idx, doc in enumerate(docs):
    print("Document text: {}".format(documents[idx]))
    print("Overall sentiment: {}".format(doc.sentiment))

async detect_languages(inputs: Union[List[str], List[azure.ai.textanalytics._models.DetectLanguageInput], List[Dict[str, str]]], country_hint: Optional[str] = None, **kwargs: Any) → List[Union[azure.ai.textanalytics._models.DetectLanguageResult, azure.ai.textanalytics._models.DocumentError]][source]¶

Detects Language for a batch of documents.

Returns the detected language and a numeric score between zero and one. Scores close to one indicate 100% certainty that the identified language is true. See https://aka.ms/talangs for the list of enabled languages.

Parameters

inputs (list[str] or list[DetectLanguageInput]) – The set of documents to process as part of this batch. If you wish to specify the ID and country_hint on a per-item basis you must use as input a list[DetectLanguageInput] or a list of dict representations of DetectLanguageInput, like {“id”: “1”, “country_hint”: “us”, “text”: “hello world”}.
country_hint (str) – A country hint for the entire batch. Accepts two letter country codes specified by ISO 3166-1 alpha-2. Per-document country hints will take precedence over whole batch hints. Defaults to “US”. If you don’t want to use a country hint, pass the empty string “”.

Keyword Arguments

model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.
show_stats (bool) – If set to true, response will contain document level statistics.

Returns

The combined list of DetectLanguageResults and DocumentErrors in the order the original documents were passed in.

Return type

list[DetectLanguageResult, DocumentError]

Raises

HttpResponseError –

Example:

Detecting language in a batch of documents.¶

from azure.ai.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.primary_language.name))
        print("ISO6391 name: {}".format(doc.primary_language.iso6391_name))
        print("Confidence score: {}\n".format(doc.primary_language.score))
    if doc.is_error:
        print(doc.id, doc.error)

async extract_key_phrases(inputs: Union[List[str], List[azure.ai.textanalytics._models.TextDocumentInput], List[Dict[str, str]]], language: Optional[str] = None, **kwargs: Any) → List[Union[azure.ai.textanalytics._models.ExtractKeyPhrasesResult, azure.ai.textanalytics._models.DocumentError]][source]¶

Extract Key Phrases from a batch of documents.

Returns a list of strings denoting the key phrases in the input text. See https://aka.ms/talangs for the list of enabled languages.

Parameters

inputs (list[str] or list[TextDocumentInput]) – The set of documents to process as part of this batch. If you wish to specify the ID and language on a per-item basis you must use as input a list[TextDocumentInput] or a list of dict representations of TextDocumentInput, like {“id”: “1”, “language”: “en”, “text”: “hello world”}.
language (str) – The 2 letter ISO 639-1 representation of language for the entire batch. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default. Per-document language will take precedence over whole batch language.

Keyword Arguments

model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.
show_stats (bool) – If set to true, response will contain document level statistics.

Returns

The combined list of ExtractKeyPhrasesResults and DocumentErrors in the order the original documents were passed in.

Return type

list[ExtractKeyPhrasesResult, DocumentError]

Raises

HttpResponseError –

Example:

Extract the key phrases in a batch of documents.¶

from azure.ai.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint, credential=self.key)
documents = [
    "Redmond is a city in King County, Washington, United States, located 15 miles east of Seattle.",
    "I need to take my cat to the veterinarian.",
    "I will travel to South America in the summer.",
]

async with text_analytics_client:
    result = await text_analytics_client.extract_key_phrases(documents)

for doc in result:
    if not doc.is_error:
        print(doc.key_phrases)
    if doc.is_error:
        print(doc.id, doc.error)

async recognize_entities(inputs: Union[List[str], List[azure.ai.textanalytics._models.TextDocumentInput], List[Dict[str, str]]], language: Optional[str] = None, **kwargs: Any) → List[Union[azure.ai.textanalytics._models.RecognizeEntitiesResult, azure.ai.textanalytics._models.DocumentError]][source]¶

Named Entity Recognition for a batch of documents.

Returns a list of general named entities in a given document. For the list of supported entity types, check: https://aka.ms/taner For the list of enabled languages, check: https://aka.ms/talangs

Parameters

inputs (list[str] or list[TextDocumentInput]) – The set of documents to process as part of this batch. If you wish to specify the ID and language on a per-item basis you must use as input a list[TextDocumentInput] or a list of dict representations of TextDocumentInput, like {“id”: “1”, “language”: “en”, “text”: “hello world”}.
language (str) – The 2 letter ISO 639-1 representation of language for the entire batch. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default. Per-document language will take precedence over whole batch language.

Keyword Arguments

model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.
show_stats (bool) – If set to true, response will contain document level statistics.

Returns

The combined list of RecognizeEntitiesResults and DocumentErrors in the order the original documents were passed in.

Return type

list[RecognizeEntitiesResult, DocumentError]

Raises

HttpResponseError –

Example:

Recognize entities in a batch of documents.¶

from azure.ai.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint, credential=self.key)
documents = [
    "Microsoft was founded by Bill Gates and Paul Allen.",
    "I had a wonderful trip to Seattle last week.",
    "I visited the Space Needle 2 times.",
]

async with text_analytics_client:
    result = await text_analytics_client.recognize_entities(documents)

docs = [doc for doc in result if not doc.is_error]

for idx, doc in enumerate(docs):
    print("\nDocument text: {}".format(documents[idx]))
    for entity in doc.entities:
        print("Entity: \t", entity.text, "\tType: \t", entity.type,
              "\tConfidence Score: \t", round(entity.score, 3))

async recognize_linked_entities(inputs: Union[List[str], List[azure.ai.textanalytics._models.TextDocumentInput], List[Dict[str, str]]], language: Optional[str] = None, **kwargs: Any) → List[Union[azure.ai.textanalytics._models.RecognizeLinkedEntitiesResult, azure.ai.textanalytics._models.DocumentError]][source]¶

Recognize linked entities from a well-known knowledge base for a batch of documents.

Returns a list of recognized entities with links to a well-known knowledge base. See https://aka.ms/talangs for supported languages in Text Analytics API.

Parameters

inputs (list[str] or list[TextDocumentInput]) – The set of documents to process as part of this batch. If you wish to specify the ID and language on a per-item basis you must use as input a list[TextDocumentInput] or a list of dict representations of TextDocumentInput, like {“id”: “1”, “language”: “en”, “text”: “hello world”}.
language (str) – The 2 letter ISO 639-1 representation of language for the entire batch. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default. Per-document language will take precedence over whole batch language.

Keyword Arguments

model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.
show_stats (bool) – If set to true, response will contain document level statistics.

Returns

The combined list of RecognizeLinkedEntitiesResults and DocumentErrors in the order the original documents were passed in.

Return type

list[RecognizeLinkedEntitiesResult, DocumentError]

Raises

HttpResponseError –

Example:

Recognize linked entities in a batch of documents.¶

from azure.ai.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 recognize_pii_entities(inputs: Union[List[str], List[azure.ai.textanalytics._models.TextDocumentInput], List[Dict[str, str]]], language: Optional[str] = None, **kwargs: Any) → List[Union[azure.ai.textanalytics._models.RecognizePiiEntitiesResult, azure.ai.textanalytics._models.DocumentError]][source]¶

Recognize entities containing personal information for a batch of documents.

Returns a list of personal information entities (“SSN”, “Bank Account”, etc) in the document. For the list of supported entity types, check https://aka.ms/tanerpii. See https://aka.ms/talangs for the list of enabled languages.

Parameters

inputs (list[str] or list[TextDocumentInput]) – The set of documents to process as part of this batch. If you wish to specify the ID and language on a per-item basis you must use as input a list[TextDocumentInput] or a list of dict representations of TextDocumentInput, like {“id”: “1”, “language”: “en”, “text”: “hello world”}.
language (str) – The 2 letter ISO 639-1 representation of language for the entire batch. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default. Per-document language will take precedence over whole batch language.

Keyword Arguments

model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.
show_stats (bool) – If set to true, response will contain document level statistics.

Returns

The combined list of RecognizePiiEntitiesResults and DocumentErrors in the order the original documents were passed in.

Return type

list[RecognizePiiEntitiesResult, DocumentError]

Raises

HttpResponseError –

Example:

Recognize personally identifiable information entities in a batch of documents.¶

from azure.ai.textanalytics.aio import TextAnalyticsClient
text_analytics_client = TextAnalyticsClient(endpoint=self.endpoint, credential=self.key)
documents = [
    "The employee's SSN is 555-55-5555.",
    "Your ABA number - 111000025 - is the first 9 digits in the lower left hand corner of your personal check.",
    "Is 998.214.865-68 your Brazilian CPF number?"
]

async with text_analytics_client:
    result = await text_analytics_client.recognize_pii_entities(documents)

docs = [doc for doc in result if not doc.is_error]

for idx, doc in enumerate(docs):
    print("Document text: {}".format(documents[idx]))
    for entity in doc.entities:
        print("Entity: {}".format(entity.text))
        print("Type: {}".format(entity.type))
        print("Confidence Score: {}\n".format(entity.score))

async azure.ai.textanalytics.aio.single_detect_language(endpoint: str, credential: str, input_text: str, country_hint: Optional[str] = 'US', **kwargs: Any) → azure.ai.textanalytics._models.DetectLanguageResult[source]¶

Detect Language for a single document.

Returns the detected language and a numeric score between zero and one. Scores close to one indicate 100% certainty that the identified language is true. See https://aka.ms/talangs for the list of enabled languages.

Parameters

endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services subscription key or a token credential from azure.identity.
input_text (str) – The single string to detect language from.
country_hint (str) – The country hint for the text. Accepts two letter country codes specified by ISO 3166-1 alpha-2. Defaults to “US”. If you don’t want to use a country hint, pass the empty string “”.

Keyword Arguments

show_stats (bool) – If set to true, response will contain document level statistics.
model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.

Returns

An instance of DetectLanguageResult.

Return type

DetectLanguageResult

Raises

HttpResponseError –

Example:

Detecting language in a single string.¶

from azure.ai.textanalytics.aio import single_detect_language

text = "I need to take my cat to the veterinarian."

result = await single_detect_language(
    endpoint=self.endpoint,
    credential=self.key,
    input_text=text,
    country_hint="US",
    show_stats=True
)

print("Language detected: {}".format(result.primary_language.name))
print("Confidence score: {}\n".format(result.primary_language.score))
print("Document Statistics:")
print("Text character count: {}".format(result.statistics.character_count))
print("Transactions count: {}".format(result.statistics.transaction_count))

async azure.ai.textanalytics.aio.single_recognize_entities(endpoint: str, credential: str, input_text: str, language: Optional[str] = 'en', **kwargs: Any) → azure.ai.textanalytics._models.RecognizeEntitiesResult[source]¶

Named Entity Recognition for a single document.

Returns a list of general named entities in a given document. For a list of supported entity types, check: https://aka.ms/taner For a list of enabled languages, check: https://aka.ms/talangs

Parameters

endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services subscription key or a token credential from azure.identity.
input_text (str) – The single string to recognize entities from.
language (str) – This is the 2 letter ISO 639-1 representation of a language. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default.

Keyword Arguments

show_stats (bool) – If set to true, response will contain document level statistics.
model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.

Returns

An instance of RecognizeEntitiesResult.

Return type

RecognizeEntitiesResult

Raises

HttpResponseError –

Example:

Recognize entities in a single string.¶

from azure.ai.textanalytics.aio import single_recognize_entities

text = "Microsoft was founded by Bill Gates and Paul Allen on April 4, 1975," \
       " to develop and sell BASIC interpreters for the Altair 8800."

result = await single_recognize_entities(
    endpoint=self.endpoint,
    credential=self.key,
    input_text=text,
    language="en"
)

for entity in result.entities:
    print("Entity: {}".format(entity.text))
    print("Type: {}".format(entity.type))
    print("Confidence Score: {0:.3f}\n".format(entity.score))

async azure.ai.textanalytics.aio.single_recognize_pii_entities(endpoint: str, credential: str, input_text: str, language: Optional[str] = 'en', **kwargs: Any) → azure.ai.textanalytics._models.RecognizePiiEntitiesResult[source]¶

Recognize entities containing personal information for a single document.

Returns a list of personal information entities (“SSN”, “Bank Account”, etc) in the document. For the list of supported entity types, check https://aka.ms/tanerpii. See https://aka.ms/talangs for the list of enabled languages.

Parameters

endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services subscription key or a token credential from azure.identity.
input_text (str) – The single string to recognize entities from.
language (str) – This is the 2 letter ISO 639-1 representation of a language. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default.

Keyword Arguments

show_stats (bool) – If set to true, response will contain document level statistics.
model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.

Returns

An instance of RecognizePiiEntitiesResult.

Return type

RecognizePiiEntitiesResult

Raises

HttpResponseError –

Example:

Recognize personally identifiable information entities in a single string.¶

from azure.ai.textanalytics.aio import single_recognize_pii_entities

text = "The employee's ABA number is 111000025 and his SSN is 555-55-5555."

result = await single_recognize_pii_entities(
    endpoint=self.endpoint,
    credential=self.key,
    input_text=text,
    language="en"
)

for entity in result.entities:
    print("Entity: {}".format(entity.text))
    print("Type: {}".format(entity.type))
    print("Confidence Score: {}\n".format(entity.score))

async azure.ai.textanalytics.aio.single_recognize_linked_entities(endpoint: str, credential: str, input_text: str, language: Optional[str] = 'en', **kwargs: Any) → azure.ai.textanalytics._models.RecognizeLinkedEntitiesResult[source]¶

Recognize linked entities from a well-known knowledge base for a single document.

Returns a list of recognized entities with links to a well-known knowledge base. See https://aka.ms/talangs for supported languages in Text Analytics API.

Parameters

endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services subscription key or a token credential from azure.identity.
input_text (str) – The single string to recognize entities from.
language (str) – This is the 2 letter ISO 639-1 representation of a language. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default.

Keyword Arguments

show_stats (bool) – If set to true, response will contain document level statistics.
model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.

Returns

An instance of RecognizeLinkedEntitiesResult

Return type

RecognizeLinkedEntitiesResult

Raises

HttpResponseError –

Example:

Recognize linked entities in a single string.¶

from azure.ai.textanalytics.aio import single_recognize_linked_entities

text = "Easter Island, a Chilean territory, is a remote volcanic island in Polynesia. " \
       "Its native name is Rapa Nui."

result = await single_recognize_linked_entities(
    endpoint=self.endpoint,
    credential=self.key,
    input_text=text,
    language="en"
)

for entity in result.entities:
    print("Entity: {}".format(entity.name))
    print("Url: {}".format(entity.url))
    print("Data Source: {}\n".format(entity.data_source))
    print("Where this entity appears in the text:")
    for idx, match in enumerate(entity.matches):
        print("Match {}: {}".format(idx+1, match.text))
        print("Score: {0:.3f}".format(match.score))
        print("Offset: {}".format(match.offset))
        print("Length: {}\n".format(match.length))

async azure.ai.textanalytics.aio.single_extract_key_phrases(endpoint: str, credential: str, input_text: str, language: Optional[str] = 'en', **kwargs: Any) → azure.ai.textanalytics._models.ExtractKeyPhrasesResult[source]¶

Extract Key Phrases for a single document.

Returns a list of strings denoting the key phrases in the input text. See https://aka.ms/talangs for the list of enabled languages.

Parameters

endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services subscription key or a token credential from azure.identity.
input_text (str) – The single string to extract key phrases from.
language (str) – This is the 2 letter ISO 639-1 representation of a language. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default.

Keyword Arguments

show_stats (bool) – If set to true, response will contain document level statistics.
model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.

Returns

An instance of ExtractKeyPhrasesResult

Return type

ExtractKeyPhrasesResult

Raises

HttpResponseError –

Example:

Extract key phrases in a single string.¶

from azure.ai.textanalytics.aio import single_extract_key_phrases

text = "Redmond is a city in King County, Washington, United States, located 15 miles east of Seattle."

result = await single_extract_key_phrases(
    endpoint=self.endpoint,
    credential=self.key,
    input_text=text,
    language="en"
)

print("Key phrases found:\n")
for phrase in result.key_phrases:
    print(phrase)

async azure.ai.textanalytics.aio.single_analyze_sentiment(endpoint: str, credential: str, input_text: str, language: Optional[str] = 'en', **kwargs: Any) → azure.ai.textanalytics._models.AnalyzeSentimentResult[source]¶

Analyze sentiment in a single document.

Returns a sentiment prediction, as well as sentiment scores for each sentiment class (Positive, Negative, and Neutral) for the document and each sentence within it. See https://aka.ms/talangs for the list of enabled languages.

Parameters

endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).
credential (str or TokenCredential) – Credentials needed for the client to connect to Azure. This can be the cognitive services subscription key or a token credential from azure.identity.
input_text (str) – The single string to analyze sentiment from.
language (str) – This is the 2 letter ISO 639-1 representation of a language. For example, use “en” for English; “es” for Spanish etc. If not set, uses “en” for English as default.

Keyword Arguments

show_stats (bool) – If set to true, response will contain document level statistics.
model_version (str) – This value indicates which model will be used for scoring, e.g. “latest”, “2019-10-01”. If a model-version is not specified, the API will default to the latest, non-preview version.

Returns

An instance of AnalyzeSentimentResult

Return type

AnalyzeSentimentResult

Raises

HttpResponseError –

Example:

Analyze sentiment in a single string.¶

from azure.ai.textanalytics.aio import single_analyze_sentiment

text = "I visited the restaurant last week. The portions were very generous. However, I did not like what " \
       "I ordered."

result = await single_analyze_sentiment(
    endpoint=self.endpoint,
    credential=self.key,
    input_text=text,
    language="en"
)

print("Overall sentiment: {}".format(result.sentiment))
print("Overall scores: positive={0:.3f}; neutral={1:.3f}; negative={2:.3f} \n".format(
    result.document_scores.positive,
    result.document_scores.neutral,
    result.document_scores.negative,
))

for idx, sentence in enumerate(result.sentences):
    print("Sentence {} sentiment: {}".format(idx+1, sentence.sentiment))
    print("Offset: {}".format(sentence.offset))
    print("Length: {}".format(sentence.length))
    print("Sentence score: positive={0:.3f}; neutral={1:.3f}; negative={2:.3f} \n".format(
        sentence.sentence_scores.positive,
        sentence.sentence_scores.neutral,
        sentence.sentence_scores.negative,
    ))