Azure Text Analytics client library for Python
The Azure Cognitive Service for Language is a cloud-based service that provides Natural Language Processing (NLP) features for understanding and analyzing text, and includes the following main features:
- Sentiment Analysis
- Named Entity Recognition
- Language Detection
- Key Phrase Extraction
- Entity Linking
- Multiple Analysis
- Personally Identifiable Information (PII) Detection
- Text Analytics for Health
- Custom Named Entity Recognition
- Custom Text Classification
- Extractive Text Summarization
- Abstractive Text Summarization
Source code
| Package (PyPI)
| Package (Conda)
| API reference documentation
| Product documentation
| Samples
Getting started
Prerequisites
Create a Cognitive Services or Language service resource
The Language service supports both multi-service and single-service access.
Create a Cognitive Services resource if you plan to access multiple cognitive services under a single endpoint/key. For Language service access only, create a Language service resource.
You can create the resource using the Azure Portal or Azure CLI following the steps in this document.
Interaction with the service using the client library begins with a client.
To create a client object, you will need the Cognitive Services or Language service endpoint
to
your resource and a credential
that allows you access:
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
credential = AzureKeyCredential("<api_key>")
text_analytics_client = TextAnalyticsClient(endpoint="https://<resource-name>.cognitiveservices.azure.com/", credential=credential)
Note that for some Cognitive Services resources the endpoint might look different from the above code snippet.
For example, https://<region>.api.cognitive.microsoft.com/
.
Install the package
Install the Azure Text Analytics client library for Python with pip:
pip install azure-ai-textanalytics
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))
Note that 5.2.X
and newer targets the Azure Cognitive Service for Language APIs. These APIs include the text analysis and natural language processing features found in the previous versions of the Text Analytics client library.
In addition, the service API has changed from semantic to date-based versioning. This version of the client library defaults to the latest supported API version, which currently is 2023-04-01
.
This table shows the relationship between SDK versions and supported API versions of the service
SDK version | Supported API version of service |
---|
5.3.X - Latest stable release | 3.0, 3.1, 2022-05-01, 2023-04-01 (default) |
5.2.X | 3.0, 3.1, 2022-05-01 (default) |
5.1.0 | 3.0, 3.1 (default) |
5.0.0 | 3.0 |
API version can be selected by passing the api_version keyword argument into the client.
For the latest Language service features, consider selecting the most recent beta API version. For production scenarios, the latest stable version is recommended. Setting to an older version may result in reduced feature compatibility.
Authenticate the client
Get the endpoint
You can find the endpoint for your Language service resource using the
Azure Portal
or Azure CLI:
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"
Get the API Key
You can get the API key from the Cognitive Services or Language service resource in the Azure Portal.
Alternatively, you can use Azure CLI snippet below to get the API key of your resource.
az cognitiveservices account keys list --name "resource-name" --resource-group "resource-group-name"
Create a TextAnalyticsClient with an API Key Credential
Once you have the value for the API key, you can pass it as a string into an instance of AzureKeyCredential. Use the key as the credential parameter
to authenticate the client:
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))
Create a TextAnalyticsClient with an Azure Active Directory Credential
To use an Azure Active Directory (AAD) token credential,
provide an instance of the desired credential type obtained from the
azure-identity library.
Note that regional endpoints do not support AAD authentication. Create a custom subdomain
name for your resource in order to use this type of authentication.
Authentication with AAD requires some initial setup:
After setup, you can choose which type of credential from azure.identity to use.
As an example, DefaultAzureCredential
can be used to authenticate the client:
Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables:
AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
Use the returned token credential to authenticate the client:
import os
from azure.ai.textanalytics import TextAnalyticsClient
from azure.identity import DefaultAzureCredential
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
credential = DefaultAzureCredential()
text_analytics_client = TextAnalyticsClient(endpoint, credential=credential)
Key concepts
TextAnalyticsClient
The Text Analytics client library provides a TextAnalyticsClient to do analysis on batches of documents.
It provides both synchronous and asynchronous operations to access a specific use of text analysis, such as language detection or key phrase extraction.
Input
A document is a single unit to be analyzed by the predictive models in the Language service.
The input for each operation is passed as a list of documents.
Each document can be passed as a string in the list, e.g.
documents = ["I hated the movie. It was so slow!", "The movie made it into my top ten favorites. What a great movie!"]
or, if you wish to pass in a per-item document id
or language
/country_hint
, they can be passed as a list of
DetectLanguageInput or
TextDocumentInput
or a dict-like representation of the object:
documents = [
{"id": "1", "language": "en", "text": "I hated the movie. It was so slow!"},
{"id": "2", "language": "en", "text": "The movie made it into my top ten favorites. What a great movie!"},
]
See service limitations for the input, including document length limits, maximum batch size, and supported text encoding.
Return Value
The return value for a single document can be a result or error object.
A heterogeneous list containing a collection of result and error objects is returned from each operation.
These results/errors are index-matched with the order of the provided documents.
A result, such as AnalyzeSentimentResult,
is the result of a text analysis operation and contains a prediction or predictions about a document input.
The error object, DocumentError, indicates that the service had trouble processing the document and contains
the reason it was unsuccessful.
Document Error Handling
You can filter for a result or error object in the list by using the is_error
attribute. For a result object this is always False
and for a
DocumentError this is True
.
For example, to filter out all DocumentErrors you might use list comprehension:
response = text_analytics_client.analyze_sentiment(documents)
successful_responses = [doc for doc in response if not doc.is_error]
You can also use the kind
attribute to filter between result types:
poller = text_analytics_client.begin_analyze_actions(documents, actions)
response = poller.result()
for result in response:
if result.kind == "SentimentAnalysis":
print(f"Sentiment is {result.sentiment}")
elif result.kind == "KeyPhraseExtraction":
print(f"Key phrases: {result.key_phrases}")
elif result.is_error is True:
print(f"Document error: {result.code}, {result.message}")
Long-Running Operations
Long-running operations are operations which consist of an initial request sent to the service to start an operation,
followed by polling the service at intervals to determine whether the operation has completed or failed, and if it has
succeeded, to get the result.
Methods that support healthcare analysis, custom text analysis, or multiple analyses are modeled as long-running operations.
The client exposes a begin_<method-name>
method that returns a poller object. Callers should wait
for the operation to complete by calling result()
on the poller object returned from the begin_<method-name>
method.
Sample code snippets are provided to illustrate using long-running operations below.
Examples
The following section provides several code snippets covering some of the most common Language service tasks, including:
Analyze Sentiment
analyze_sentiment looks at its input text and determines whether its sentiment is positive, negative, neutral or mixed. It's response includes per-sentence sentiment analysis and confidence scores.
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
"""I had the best day of my life. I decided to go sky-diving and it made me appreciate my whole life so much more.
I developed a deep-connection with my instructor as well, and I feel as if I've made a life-long friend in her.""",
"""This was a waste of my time. All of the views on this drop are extremely boring, all I saw was grass. 0/10 would
not recommend to any divers, even first timers.""",
"""This was pretty good! The sights were ok, and I had fun with my instructors! Can't complain too much about my experience""",
"""I only have one word for my experience: WOW!!! I can't believe I have had such a wonderful skydiving company right
in my backyard this whole time! I will definitely be a repeat customer, and I want to take my grandmother skydiving too,
I know she'll love it!"""
]
result = text_analytics_client.analyze_sentiment(documents, show_opinion_mining=True)
docs = [doc for doc in result if not doc.is_error]
print("Let's visualize the sentiment of each of these documents")
for idx, doc in enumerate(docs):
print(f"Document text: {documents[idx]}")
print(f"Overall sentiment: {doc.sentiment}")
The returned response is a heterogeneous list of result and error objects: list[AnalyzeSentimentResult, DocumentError]
Please refer to the service documentation for a conceptual discussion of sentiment analysis. To see how to conduct more granular analysis into the opinions related to individual aspects (such as attributes of a product or service) in a text, see here.
Recognize Entities
recognize_entities recognizes and categories entities in its input text as people, places, organizations, date/time, quantities, percentages, currencies, and more.
import os
import typing
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
reviews = [
"""I work for Foo Company, and we hired Contoso for our annual founding ceremony. The food
was amazing and we all can't say enough good words about the quality and the level of service.""",
"""We at the Foo Company re-hired Contoso after all of our past successes with the company.
Though the food was still great, I feel there has been a quality drop since their last time
catering for us. Is anyone else running into the same problem?""",
"""Bar Company is over the moon about the service we received from Contoso, the best sliders ever!!!!"""
]
result = text_analytics_client.recognize_entities(reviews)
result = [review for review in result if not review.is_error]
organization_to_reviews: typing.Dict[str, typing.List[str]] = {}
for idx, review in enumerate(result):
for entity in review.entities:
print(f"Entity '{entity.text}' has category '{entity.category}'")
if entity.category == 'Organization':
organization_to_reviews.setdefault(entity.text, [])
organization_to_reviews[entity.text].append(reviews[idx])
for organization, reviews in organization_to_reviews.items():
print(
"\n\nOrganization '{}' has left us the following review(s): {}".format(
organization, "\n\n".join(reviews)
)
)
The returned response is a heterogeneous list of result and error objects: list[RecognizeEntitiesResult, DocumentError]
Please refer to the service documentation for a conceptual discussion of named entity recognition
and supported types.
Recognize Linked Entities
recognize_linked_entities recognizes and disambiguates the identity of each entity found in its input text (for example,
determining whether an occurrence of the word Mars refers to the planet, or to the
Roman god of war). Recognized entities are associated with URLs to a well-known knowledge base, like Wikipedia.
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
"""
Microsoft was founded by Bill Gates with some friends he met at Harvard. One of his friends,
Steve Ballmer, eventually became CEO after Bill Gates as well. Steve Ballmer eventually stepped
down as CEO of Microsoft, and was succeeded by Satya Nadella.
Microsoft originally moved its headquarters to Bellevue, Washington in January 1979, but is now
headquartered in Redmond.
"""
]
result = text_analytics_client.recognize_linked_entities(documents)
docs = [doc for doc in result if not doc.is_error]
print(
"Let's map each entity to it's Wikipedia article. I also want to see how many times each "
"entity is mentioned in a document\n\n"
)
entity_to_url = {}
for doc in docs:
for entity in doc.entities:
print("Entity '{}' has been mentioned '{}' time(s)".format(
entity.name, len(entity.matches)
))
if entity.data_source == "Wikipedia":
entity_to_url[entity.name] = entity.url
The returned response is a heterogeneous list of result and error objects: list[RecognizeLinkedEntitiesResult, DocumentError]
Please refer to the service documentation for a conceptual discussion of entity linking
and supported types.
Recognize PII Entities
recognize_pii_entities recognizes and categorizes Personally Identifiable Information (PII) entities in its input text, such as
Social Security Numbers, bank account information, credit card numbers, and more.
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(
endpoint=endpoint, credential=AzureKeyCredential(key)
)
documents = [
"""Parker Doe has repaid all of their loans as of 2020-04-25.
Their SSN is 859-98-0987. To contact them, use their phone number
555-555-5555. They are originally from Brazil and have Brazilian CPF number 998.214.865-68"""
]
result = text_analytics_client.recognize_pii_entities(documents)
docs = [doc for doc in result if not doc.is_error]
print(
"Let's compare the original document with the documents after redaction. "
"I also want to comb through all of the entities that got redacted"
)
for idx, doc in enumerate(docs):
print(f"Document text: {documents[idx]}")
print(f"Redacted document text: {doc.redacted_text}")
for entity in doc.entities:
print("...Entity '{}' with category '{}' got redacted".format(
entity.text, entity.category
))
The returned response is a heterogeneous list of result and error objects: list[RecognizePiiEntitiesResult, DocumentError]
Please refer to the service documentation for supported PII entity types.
Note: The Recognize PII Entities service is available in API version v3.1 and newer.
extract_key_phrases determines the main talking points in its input text. For example, for the input text "The food was delicious and there were wonderful staff", the API returns: "food" and "wonderful staff".
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
articles = [
"""
Washington, D.C. Autumn in DC is a uniquely beautiful season. The leaves fall from the trees
in a city chock-full of forests, leaving yellow leaves on the ground and a clearer view of the
blue sky above...
""",
"""
Redmond, WA. In the past few days, Microsoft has decided to further postpone the start date of
its United States workers, due to the pandemic that rages with no end in sight...
""",
"""
Redmond, WA. Employees at Microsoft can be excited about the new coffee shop that will open on campus
once workers no longer have to work remotely...
"""
]
result = text_analytics_client.extract_key_phrases(articles)
for idx, doc in enumerate(result):
if not doc.is_error:
print("Key phrases in article #{}: {}".format(
idx + 1,
", ".join(doc.key_phrases)
))
The returned response is a heterogeneous list of result and error objects: list[ExtractKeyPhrasesResult, DocumentError]
Please refer to the service documentation for a conceptual discussion of key phrase extraction.
Detect Language
detect_language determines the language of its input text, including the confidence score of the predicted language.
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
"""
The concierge Paulette was extremely helpful. Sadly when we arrived the elevator was broken, but with Paulette's help we barely noticed this inconvenience.
She arranged for our baggage to be brought up to our room with no extra charge and gave us a free meal to refurbish all of the calories we lost from
walking up the stairs :). Can't say enough good things about my experience!
""",
"""
最近由于工作压力太大,我们决定去富酒店度假。那儿的温泉实在太舒服了,我跟我丈夫都完全恢复了工作前的青春精神!加油!
"""
]
result = text_analytics_client.detect_language(documents)
reviewed_docs = [doc for doc in result if not doc.is_error]
print("Let's see what language each review is in!")
for idx, doc in enumerate(reviewed_docs):
print("Review #{} is in '{}', which has ISO639-1 name '{}'\n".format(
idx, doc.primary_language.name, doc.primary_language.iso6391_name
))
The returned response is a heterogeneous list of result and error objects: list[DetectLanguageResult, DocumentError]
Please refer to the service documentation for a conceptual discussion of language detection
and language and regional support.
Healthcare Entities Analysis
Long-running operation begin_analyze_healthcare_entities extracts entities recognized within the healthcare domain, and identifies relationships between entities within the input document and links to known sources of information in various well known databases, such as UMLS, CHV, MSH, etc.
import os
import typing
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient, HealthcareEntityRelation
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(
endpoint=endpoint,
credential=AzureKeyCredential(key),
)
documents = [
"""
Patient needs to take 100 mg of ibuprofen, and 3 mg of potassium. Also needs to take
10 mg of Zocor.
""",
"""
Patient needs to take 50 mg of ibuprofen, and 2 mg of Coumadin.
"""
]
poller = text_analytics_client.begin_analyze_healthcare_entities(documents)
result = poller.result()
docs = [doc for doc in result if not doc.is_error]
print("Let's first visualize the outputted healthcare result:")
for doc in docs:
for entity in doc.entities:
print(f"Entity: {entity.text}")
print(f"...Normalized Text: {entity.normalized_text}")
print(f"...Category: {entity.category}")
print(f"...Subcategory: {entity.subcategory}")
print(f"...Offset: {entity.offset}")
print(f"...Confidence score: {entity.confidence_score}")
if entity.data_sources is not None:
print("...Data Sources:")
for data_source in entity.data_sources:
print(f"......Entity ID: {data_source.entity_id}")
print(f"......Name: {data_source.name}")
if entity.assertion is not None:
print("...Assertion:")
print(f"......Conditionality: {entity.assertion.conditionality}")
print(f"......Certainty: {entity.assertion.certainty}")
print(f"......Association: {entity.assertion.association}")
for relation in doc.entity_relations:
print(f"Relation of type: {relation.relation_type} has the following roles")
for role in relation.roles:
print(f"...Role '{role.name}' with entity '{role.entity.text}'")
print("------------------------------------------")
print("Now, let's get all of medication dosage relations from the documents")
dosage_of_medication_relations = [
entity_relation
for doc in docs
for entity_relation in doc.entity_relations if entity_relation.relation_type == HealthcareEntityRelation.DOSAGE_OF_MEDICATION
]
Note: Healthcare Entities Analysis is only available with API version v3.1 and newer.
Multiple Analysis
Long-running operation begin_analyze_actions performs multiple analyses over one set of documents in a single request. Currently it is supported using any combination of the following Language APIs in a single request:
- Entities Recognition
- PII Entities Recognition
- Linked Entity Recognition
- Key Phrase Extraction
- Sentiment Analysis
- Custom Entity Recognition (API version 2022-05-01 and newer)
- Custom Single Label Classification (API version 2022-05-01 and newer)
- Custom Multi Label Classification (API version 2022-05-01 and newer)
- Healthcare Entities Analysis (API version 2022-05-01 and newer)
- Extractive Summarization (API version 2023-04-01 and newer)
- Abstractive Summarization (API version 2023-04-01 and newer)
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import (
TextAnalyticsClient,
RecognizeEntitiesAction,
RecognizeLinkedEntitiesAction,
RecognizePiiEntitiesAction,
ExtractKeyPhrasesAction,
AnalyzeSentimentAction,
)
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]
text_analytics_client = TextAnalyticsClient(
endpoint=endpoint,
credential=AzureKeyCredential(key),
)
documents = [
'We went to Contoso Steakhouse located at midtown NYC last week for a dinner party, and we adore the spot! '
'They provide marvelous food and they have a great menu. The chief cook happens to be the owner (I think his name is John Doe) '
'and he is super nice, coming out of the kitchen and greeted us all.'
,
'We enjoyed very much dining in the place! '
'The Sirloin steak I ordered was tender and juicy, and the place was impeccably clean. You can even pre-order from their '
'online menu at www.contososteakhouse.com, call 312-555-0176 or send email to order@contososteakhouse.com! '
'The only complaint I have is the food didn\'t come fast enough. Overall I highly recommend it!'
]
poller = text_analytics_client.begin_analyze_actions(
documents,
display_name="Sample Text Analysis",
actions=[
RecognizeEntitiesAction(),
RecognizePiiEntitiesAction(),
ExtractKeyPhrasesAction(),
RecognizeLinkedEntitiesAction(),
AnalyzeSentimentAction(),
],
)
document_results = poller.result()
for doc, action_results in zip(documents, document_results):
print(f"\nDocument text: {doc}")
for result in action_results:
if result.kind == "EntityRecognition":
print("...Results of Recognize Entities Action:")
for entity in result.entities:
print(f"......Entity: {entity.text}")
print(f".........Category: {entity.category}")
print(f".........Confidence Score: {entity.confidence_score}")
print(f".........Offset: {entity.offset}")
elif result.kind == "PiiEntityRecognition":
print("...Results of Recognize PII Entities action:")
for pii_entity in result.entities:
print(f"......Entity: {pii_entity.text}")
print(f".........Category: {pii_entity.category}")
print(f".........Confidence Score: {pii_entity.confidence_score}")
elif result.kind == "KeyPhraseExtraction":
print("...Results of Extract Key Phrases action:")
print(f"......Key Phrases: {result.key_phrases}")
elif result.kind == "EntityLinking":
print("...Results of Recognize Linked Entities action:")
for linked_entity in result.entities:
print(f"......Entity name: {linked_entity.name}")
print(f".........Data source: {linked_entity.data_source}")
print(f".........Data source language: {linked_entity.language}")
print(
f".........Data source entity ID: {linked_entity.data_source_entity_id}"
)
print(f".........Data source URL: {linked_entity.url}")
print(".........Document matches:")
for match in linked_entity.matches:
print(f"............Match text: {match.text}")
print(f"............Confidence Score: {match.confidence_score}")
print(f"............Offset: {match.offset}")
print(f"............Length: {match.length}")
elif result.kind == "SentimentAnalysis":
print("...Results of Analyze Sentiment action:")
print(f"......Overall sentiment: {result.sentiment}")
print(
f"......Scores: positive={result.confidence_scores.positive}; \
neutral={result.confidence_scores.neutral}; \
negative={result.confidence_scores.negative} \n"
)
elif result.is_error is True:
print(
f"...Is an error with code '{result.error.code}' and message '{result.error.message}'"
)
print("------------------------------------------")
The returned response is an object encapsulating multiple iterables, each representing results of individual analyses.
Note: Multiple analysis is available in API version v3.1 and newer.
Optional Configuration
Optional keyword arguments can be passed in at the client and per-operation level.
The azure-core reference documentation
describes available configurations for retries, logging, transport protocols, and more.
Troubleshooting
General
The Text Analytics client will raise exceptions defined in Azure Core.
Logging
This library uses the standard
logging library for logging.
Basic information about HTTP sessions (URLs, headers, etc.) is logged at INFO
level.
Detailed DEBUG level logging, including request/response bodies and unredacted
headers, can be enabled on a client with the logging_enable
keyword argument:
import sys
import logging
from azure.identity import DefaultAzureCredential
from azure.ai.textanalytics import TextAnalyticsClient
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)
endpoint = "https://<resource-name>.cognitiveservices.azure.com/"
credential = DefaultAzureCredential()
text_analytics_client = TextAnalyticsClient(endpoint, credential, logging_enable=True)
result = text_analytics_client.analyze_sentiment(["I did not like the restaurant. The food was too spicy."])
Similarly, logging_enable
can enable detailed logging for a single operation,
even when it isn't enabled for the client:
result = text_analytics_client.analyze_sentiment(documents, logging_enable=True)
Next steps
More sample code
These code samples show common scenario operations with the Azure Text Analytics client library.
Authenticate the client with a Cognitive Services/Language service API key or a token credential from azure-identity:
Common scenarios
Advanced scenarios
Additional documentation
For more extensive documentation on Azure Cognitive Service for Language, see the Language Service documentation on docs.microsoft.com.
Contributing
This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit cla.microsoft.com.
When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.
This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.
Release History
5.3.0 (2023-06-15)
This version of the client library defaults to the service API version 2023-04-01
.
Breaking Changes
Note: The following changes are only breaking from the previous beta. They are not breaking against previous stable versions.
- Renamed model
ExtractSummaryAction
to ExtractiveSummaryAction
. - Renamed model
ExtractSummaryResult
to ExtractiveSummaryResult
. - Renamed client method
begin_abstractive_summary
to begin_abstract_summary
. - Removed
dynamic_classification
client method and related types: DynamicClassificationResult
and ClassificationType
. - Removed keyword arguments
fhir_version
and document_type
from begin_analyze_healthcare_entities
and AnalyzeHealthcareEntitiesAction
. - Removed property
fhir_bundle
from AnalyzeHealthcareEntitiesResult
. - Removed enum
HealthcareDocumentType
. - Removed property
resolutions
from CategorizedEntity
. - Removed models and enums related to resolutions:
ResolutionKind
, AgeResolution
, AreaResolution
,
CurrencyResolution
, DateTimeResolution
, InformationResolution
, LengthResolution
,
NumberResolution
, NumericRangeResolution
, OrdinalResolution
, SpeedResolution
, TemperatureResolution
,
TemporalSpanResolution
, VolumeResolution
, WeightResolution
, AgeUnit
, AreaUnit
, TemporalModifier
,
InformationUnit
, LengthUnit
, NumberKind
, RangeKind
, RelativeTo
, SpeedUnit
, TemperatureUnit
,
VolumeUnit
, DateTimeSubKind
, and WeightUnit
. - Removed property
detected_language
from RecognizeEntitiesResult
, RecognizePiiEntitiesResult
, AnalyzeHealthcareEntitiesResult
,
ExtractKeyPhrasesResult
, RecognizeLinkedEntitiesResult
, AnalyzeSentimentResult
, RecognizeCustomEntitiesResult
,
ClassifyDocumentResult
, ExtractSummaryResult
, and AbstractSummaryResult
. - Removed property
script
from DetectedLanguage
.
Features Added
- New enum values added for
HealthcareEntityCategory
and HealthcareEntityRelation
.
5.3.0b2 (2023-03-07)
This version of the client library defaults to the service API version 2022-10-01-preview
.
Features Added
- Added
begin_extract_summary
client method to perform extractive summarization on documents. - Added
begin_abstractive_summary
client method to perform abstractive summarization on documents.
Breaking Changes
- Removed models
BaseResolution
and BooleanResolution
. - Removed enum value
BooleanResolution
from ResolutionKind
. - Renamed model
AbstractSummaryAction
to AbstractiveSummaryAction
. - Renamed model
AbstractSummaryResult
to AbstractiveSummaryResult
. - Removed keyword argument
autodetect_default_language
from long-running operation APIs.
Other Changes
- Improved static typing in the client library.
5.3.0b1 (2022-11-17)
This version of the client library defaults to the service API version 2022-10-01-preview
.
Features Added
- Added the Extractive Summarization feature and related models:
ExtractSummaryAction
, ExtractSummaryResult
, and SummarySentence
.
Access the feature through the begin_analyze_actions
API. - Added keyword arguments
fhir_version
and document_type
to begin_analyze_healthcare_entities
and AnalyzeHealthcareEntitiesAction
. - Added property
fhir_bundle
to AnalyzeHealthcareEntitiesResult
. - Added property
confidence_score
to HealthcareRelation
. - Added enum
HealthcareDocumentType
. - Added property
resolutions
to CategorizedEntity
. - Added models and enums related to resolutions:
BaseResolution
, ResolutionKind
, AgeResolution
, AreaResolution
,
BooleanResolution
, CurrencyResolution
, DateTimeResolution
, InformationResolution
, LengthResolution
,
NumberResolution
, NumericRangeResolution
, OrdinalResolution
, SpeedResolution
, TemperatureResolution
,
TemporalSpanResolution
, VolumeResolution
, WeightResolution
, AgeUnit
, AreaUnit
, TemporalModifier
,
InformationUnit
, LengthUnit
, NumberKind
, RangeKind
, RelativeTo
, SpeedUnit
, TemperatureUnit
,
VolumeUnit
, DateTimeSubKind
, and WeightUnit
. - Added the Abstractive Summarization feature and related models:
AbstractSummaryAction
, AbstractSummaryResult
, AbstractiveSummary
,
and SummaryContext
. Access the feature through the begin_analyze_actions
API. - Added automatic language detection to long-running operation APIs. Pass
auto
into the document language
hint to use this feature. - Added
autodetect_default_language
to long-running operation APIs. Pass as the default/fallback language for automatic language detection. - Added property
detected_language
to RecognizeEntitiesResult
, RecognizePiiEntitiesResult
, AnalyzeHealthcareEntitiesResult
,
ExtractKeyPhrasesResult
, RecognizeLinkedEntitiesResult
, AnalyzeSentimentResult
, RecognizeCustomEntitiesResult
,
ClassifyDocumentResult
, ExtractSummaryResult
, and AbstractSummaryResult
to indicate the language detected by automatic language detection. - Added property
script
to DetectedLanguage
to indicate the script of the input document. - Added the
dynamic_classification
client method to perform dynamic classification on documents without needing to train a model.
Other Changes
- Removed dependency on
msrest
.
5.2.1 (2022-10-26)
Bugs Fixed
- Returns a more helpful message in the document error when all documents fail for an action in the
begin_analyze_actions
API.
5.2.0 (2022-09-08)
Other Changes
This version of the client library marks a stable release and defaults to the service API version 2022-05-01
.
Includes all changes from 5.2.0b1
to 5.2.0b5
.
5.2.0b5 (2022-08-11)
The version of this client library defaults to the API version 2022-05-01
.
Features Added
- Added
begin_recognize_custom_entities
client method to recognize custom named entities in documents. - Added
begin_single_label_classify
client method to perform custom single label classification on documents. - Added
begin_multi_label_classify
client method to perform custom multi label classification on documents. - Added property
details
on returned poller objects which contain long-running operation metadata. - Added
TextAnalysisLROPoller
and AsyncTextAnalysisLROPoller
protocols to describe the return types from long-running operations. - Added
cancel
method on the poller objects. Call it to cancel a long-running operation that's in progress. - Added property
kind
to RecognizeEntitiesResult
, RecognizePiiEntitiesResult
, AnalyzeHealthcareEntitiesResult
,
DetectLanguageResult
, ExtractKeyPhrasesResult
, RecognizeLinkedEntitiesResult
, AnalyzeSentimentResult
,
RecognizeCustomEntitiesResult
, ClassifyDocumentResult
, and DocumentError
. - Added enum
TextAnalysisKind
.
Breaking Changes
- Removed the Extractive Text Summarization feature and related models:
ExtractSummaryAction
, ExtractSummaryResult
, and SummarySentence
. To access this beta feature, install the 5.2.0b4
version of the client library. - Removed the
FHIR
feature and related keyword argument and property: fhir_version
and fhir_bundle
. To access this beta feature, install the 5.2.0b4
version of the client library. SingleCategoryClassifyResult
and MultiCategoryClassifyResult
models have been merged into one model: ClassifyDocumentResult
.- Renamed
SingleCategoryClassifyAction
to SingleLabelClassifyAction
- Renamed
MultiCategoryClassifyAction
to MultiLabelClassifyAction
.
Bugs Fixed
- A
HttpResponseError
will be immediately raised when the call quota volume is exceeded in a F0
tier Language resource.
Other Changes
5.2.0b4 (2022-05-18)
Note that this is the first version of the client library that targets the Azure Cognitive Service for Language APIs which includes the existing text analysis and natural language processing features found in the Text Analytics client library.
In addition, the service API has changed from semantic to date-based versioning. This version of the client library defaults to the latest supported API version, which currently is 2022-04-01-preview
. Support for v3.2-preview.2
is removed, however, all functionalities are included in the latest version.
Features Added
- Added support for Healthcare Entities Analysis through the
begin_analyze_actions
API with the AnalyzeHealthcareEntitiesAction
type. - Added keyword argument
fhir_version
to begin_analyze_healthcare_entities
and AnalyzeHealthcareEntitiesAction
. Use the keyword to indicate the version for the fhir_bundle
contained on the AnalyzeHealthcareEntitiesResult
. - Added property
fhir_bundle
to AnalyzeHealthcareEntitiesResult
. - Added keyword argument
display_name
to begin_analyze_healthcare_entities
.
5.2.0b3 (2022-03-08)
Bugs Fixed
string_index_type
now correctly defaults to the Python default UnicodeCodePoint
for AnalyzeSentimentAction
and RecognizeCustomEntitiesAction
.- Fixed a bug in
begin_analyze_actions
where incorrect action types were being sent in the request if targeting the older API version v3.1
in the beta version of the client library. string_index_type
option Utf16CodePoint
is corrected to Utf16CodeUnit
.
Other Changes
- Python 2.7 is no longer supported. Please use Python version 3.6 or later.
5.2.0b2 (2021-11-02)
This version of the SDK defaults to the latest supported API version, which currently is v3.2-preview.2
.
Features Added
- Added support for Custom Entities Recognition through the
begin_analyze_actions
API with the RecognizeCustomEntitiesAction
and RecognizeCustomEntitiesResult
types. - Added support for Custom Single Classification through the
begin_analyze_actions
API with the SingleCategoryClassifyAction
and SingleCategoryClassifyActionResult
types. - Added support for Custom Multi Classification through the
begin_analyze_actions
API with the MultiCategoryClassifyAction
and MultiCategoryClassifyActionResult
types. - Multiple of the same action type is now supported with
begin_analyze_actions
.
Bugs Fixed
- Restarting a long-running operation from a saved state is now supported for the
begin_analyze_actions
and begin_recognize_healthcare_entities
methods. - In the event of an action level error, available partial results are now returned for any successful actions in
begin_analyze_actions
.
Other Changes
- Package requires azure-core version 1.19.1 or greater
5.2.0b1 (2021-08-09)
This version of the SDK defaults to the latest supported API version, which currently is v3.2-preview.1
.
Features Added
- Added support for Extractive Summarization actions through the
ExtractSummaryAction
type.
Bugs Fixed
RecognizePiiEntitiesAction
option disable_service_logs
now correctly defaults to True
.
Other Changes
- Python 3.5 is no longer supported.
5.1.0 (2021-07-07)
This version of the SDK defaults to the latest supported API version, which currently is v3.1
.
Includes all changes from 5.1.0b1
to 5.1.0b7
.
Note: this version will be the last to officially support Python 3.5, future versions will require Python 2.7 or Python 3.6+.
Features Added
- Added
catagories_filter
to RecognizePiiEntitiesAction
- Added
HealthcareEntityCategory
- Added AAD support for the
begin_analyze_healthcare_entities
methods.
Breaking Changes
- Changed: the response structure of
being_analyze_actions
. Now, we return a list of results, where each result is a list of the action results for the document, in the order the documents and actions were passed. - Changed:
begin_analyze_actions
now accepts a single action per type. A ValueError
is raised if duplicate actions are passed. - Removed:
AnalyzeActionsType
- Removed:
AnalyzeActionsResult
- Removed:
AnalyzeActionsError
- Removed:
HealthcareEntityRelationRoleType
- Changed: renamed
HealthcareEntityRelationType
to HealthcareEntityRelation
- Changed: renamed
PiiEntityCategoryType
to PiiEntityCategory
- Changed: renamed
PiiEntityDomainType
to PiiEntityDomain
5.1.0b7 (2021-05-18)
Breaking Changes
- Renamed
begin_analyze_batch_actions
to begin_analyze_actions
. - Renamed
AnalyzeBatchActionsType
to AnalyzeActionsType
. - Renamed
AnalyzeBatchActionsResult
to AnalyzeActionsResult
. - Renamed
AnalyzeBatchActionsError
to AnalyzeActionsError
. - Renamed
AnalyzeHealthcareEntitiesResultItem
to AnalyzeHealthcareEntitiesResult
. - Fixed
AnalyzeHealthcareEntitiesResult
's statistics
to be the correct type, TextDocumentStatistics
- Remove
RequestStatistics
, use TextDocumentBatchStatistics
instead
New Features
- Added enums
EntityConditionality
, EntityCertainty
, and EntityAssociation
. - Added
AnalyzeSentimentAction
as a supported action type for begin_analyze_batch_actions
. - Added kwarg
disable_service_logs
. If set to true, you opt-out of having your text input logged on the service side for troubleshooting.
5.1.0b6 (2021-03-09)
Breaking Changes
- By default, we now target the service's
v3.1-preview.4
endpoint through enum value TextAnalyticsApiVersion.V3_1_PREVIEW
- Removed property
related_entities
on HealthcareEntity
and added entity_relations
onto the document response level for healthcare - Renamed properties
aspect
and opinions
to target
and assessments
respectively in class MinedOpinion
. - Renamed classes
AspectSentiment
and OpinionSentiment
to TargetSentiment
and AssessmentSentiment
respectively.
New Features
- Added
RecognizeLinkedEntitiesAction
as a supported action type for begin_analyze_batch_actions
. - Added parameter
categories_filter
to the recognize_pii_entities
client method. - Added enum
PiiEntityCategoryType
. - Add property
normalized_text
to HealthcareEntity
. This property is a normalized version of the text
property that already
exists on the HealthcareEntity
- Add property
assertion
onto HealthcareEntity
. This contains assertions about the entity itself, i.e. if the entity represents a diagnosis,
is this diagnosis conditional on a symptom?
Known Issues
begin_analyze_healthcare_entities
is currently in gated preview and can not be used with AAD credentials. For more information, see the Text Analytics for Health documentation.- At time of this SDK release, the service is not respecting the value passed through
model_version
to begin_analyze_healthcare_entities
, it only uses the latest model.
5.1.0b5 (2021-02-10)
Breaking Changes
- Rename
begin_analyze
to begin_analyze_batch_actions
. - Now instead of separate parameters for all of the different types of actions you can pass to
begin_analyze_batch_actions
, we accept one parameter actions
,
which is a list of actions you would like performed. The results of the actions are returned in the same order as when inputted. - The response object from
begin_analyze_batch_actions
has also changed. Now, after the completion of your long running operation, we return a paged iterable
of action results, in the same order they've been inputted. The actual document results for each action are included under property document_results
of
each action result.
New Features
- Renamed
begin_analyze_healthcare
to begin_analyze_healthcare_entities
. - Renamed
AnalyzeHealthcareResult
to AnalyzeHealthcareEntitiesResult
and AnalyzeHealthcareResultItem
to AnalyzeHealthcareEntitiesResultItem
. - Renamed
HealthcareEntityLink
to HealthcareEntityDataSource
and renamed its properties id
to entity_id
and data_source
to name
. - Removed
relations
from AnalyzeHealthcareEntitiesResultItem
and added related_entities
to HealthcareEntity
. - Moved the cancellation logic for the Analyze Healthcare Entities service from
the service client to the poller object returned from
begin_analyze_healthcare_entities
. - Exposed Analyze Healthcare Entities operation metadata on the poller object returned from
begin_analyze_healthcare_entities
. - No longer need to specify
api_version=TextAnalyticsApiVersion.V3_1_PREVIEW_3
when calling begin_analyze
and begin_analyze_healthcare_entities
. begin_analyze_healthcare_entities
is still in gated preview though. - Added a new parameter
string_index_type
to the service client methods begin_analyze_healthcare_entities
, analyze_sentiment
, recognize_entities
, recognize_pii_entities
, and recognize_linked_entities
which tells the service how to interpret string offsets. - Added property
length
to CategorizedEntity
, SentenceSentiment
, LinkedEntityMatch
, AspectSentiment
, OpinionSentiment
, PiiEntity
and
HealthcareEntity
.
5.1.0b4 (2021-01-12)
Bug Fixes
- Package requires azure-core version 1.8.2 or greater
5.1.0b3 (2020-11-19)
New Features
- We have added method
begin_analyze
, which supports long-running batch process of Named Entity Recognition, Personally identifiable Information, and Key Phrase Extraction. To use, you must specify api_version=TextAnalyticsApiVersion.V3_1_PREVIEW_3
when creating your client. - We have added method
begin_analyze_healthcare
, which supports the service's Health API. Since the Health API is currently only available in a gated preview, you need to have your subscription on the service's allow list, and you must specify api_version=TextAnalyticsApiVersion.V3_1_PREVIEW_3
when creating your client. Note that since this is a gated preview, AAD is not supported. More information here.
5.1.0b2 (2020-10-06)
Breaking changes
- Removed property
length
from CategorizedEntity
, SentenceSentiment
, LinkedEntityMatch
, AspectSentiment
, OpinionSentiment
, and PiiEntity
.
To get the length of the text in these models, just call len()
on the text
property. - When a parameter or endpoint is not compatible with the API version you specify, we will now return a
ValueError
instead of a NotImplementedError
. - Client side validation of input is now disabled by default. This means there will be no
ValidationError
s thrown by the client SDK in the case of malformed input. The error will now be thrown by the service through an HttpResponseError
.
5.1.0b1 (2020-09-17)
New features
- We are now targeting the service's v3.1-preview API as the default. If you would like to still use version v3.0 of the service,
pass in
v3.0
to the kwarg api_version
when creating your TextAnalyticsClient - We have added an API
recognize_pii_entities
which returns entities containing personally identifiable information for a batch of documents. Only available for API version v3.1-preview and up. - Added
offset
and length
properties for CategorizedEntity
, SentenceSentiment
, and LinkedEntityMatch
. These properties are only available for API versions v3.1-preview and up.
length
is the number of characters in the text of these modelsoffset
is the offset of the text from the start of the document
- We now have added support for opinion mining. To use this feature, you need to make sure you are using the service's
v3.1-preview API. To get this support pass
show_opinion_mining
as True when calling the analyze_sentiment
endpoint - Add property
bing_entity_search_api_id
to the LinkedEntity
class. This property is only available for v3.1-preview and up, and it is to be
used in conjunction with the Bing Entity Search API to fetch additional relevant information about the returned entity.
5.0.0 (2020-07-27)
- Re-release of GA version 1.0.0 with an updated version
1.0.0 (2020-06-09)
- First stable release of the azure-ai-textanalytics package. Targets the service's v3.0 API.
1.0.0b6 (2020-05-27)
New features
- We now have a
warnings
property on each document-level response object returned from the endpoints. It is a list of TextAnalyticsWarning
s. - Added
text
property to SentenceSentiment
Breaking changes
- Now targets only the service's v3.0 API, instead of the v3.0-preview.1 API
score
attribute of DetectedLanguage
has been renamed to confidence_score
- Removed
grapheme_offset
and grapheme_length
from CategorizedEntity
, SentenceSentiment
, and LinkedEntityMatch
TextDocumentStatistics
attribute grapheme_count
has been renamed to character_count
1.0.0b5
- This was a broken release
1.0.0b4 (2020-04-07)
Breaking changes
- Removed the
recognize_pii_entities
endpoint and all related models (RecognizePiiEntitiesResult
and PiiEntity
)
from this library. - Removed
TextAnalyticsApiKeyCredential
and now using AzureKeyCredential
from azure.core.credentials as key credential score
attribute has been renamed to confidence_score
for the CategorizedEntity
, LinkedEntityMatch
, and
PiiEntity
models- All input parameters
inputs
have been renamed to documents
1.0.0b3 (2020-03-10)
Breaking changes
SentimentScorePerLabel
has been renamed to SentimentConfidenceScores
AnalyzeSentimentResult
and SentenceSentiment
attribute sentiment_scores
has been renamed to confidence_scores
TextDocumentStatistics
attribute character_count
has been renamed to grapheme_count
LinkedEntity
attribute id
has been renamed to data_source_entity_id
- Parameters
country_hint
and language
are now passed as keyword arguments - The keyword argument
response_hook
has been renamed to raw_response_hook
length
and offset
attributes have been renamed to grapheme_length
and grapheme_offset
for the SentenceSentiment
,
CategorizedEntity
, PiiEntity
, and LinkedEntityMatch
models
New features
- Pass
country_hint="none"
to not use the default country hint of "US"
.
Dependency updates
1.0.0b2 (2020-02-11)
Breaking changes
- The single text, module-level operations
single_detect_language()
, single_recognize_entities()
, single_extract_key_phrases()
, single_analyze_sentiment()
, single_recognize_pii_entities()
, and single_recognize_linked_entities()
have been removed from the client library. Use the batching methods for optimal performance in production environments. - To use an API key as the credential for authenticating the client, a new credential class
TextAnalyticsApiKeyCredential("<api_key>")
must be passed in for the credential
parameter.
Passing the API key as a string is no longer supported. detect_languages()
is renamed to detect_language()
.- The
TextAnalyticsError
model has been simplified to an object with only attributes code
, message
, and target
. NamedEntity
has been renamed to CategorizedEntity
and its attributes type
to category
and subtype
to subcategory
.RecognizePiiEntitiesResult
now contains on the object a list of PiiEntity
instead of NamedEntity
.AnalyzeSentimentResult
attribute document_scores
has been renamed to sentiment_scores
.SentenceSentiment
attribute sentence_scores
has been renamed to sentiment_scores
.SentimentConfidenceScorePerLabel
has been renamed to SentimentScorePerLabel
.DetectLanguageResult
no longer has attribute detected_languages
. Use primary_language
to access the detected language in text.
New features
- Credential class
TextAnalyticsApiKeyCredential
provides an update_key()
method which allows you to update the API key for long-lived clients.
Fixes and improvements
__repr__
has been added to all of the response objects.- If you try to access a result attribute on a
DocumentError
object, an AttributeError
is raised with a custom error message that provides the document ID and error of the invalid document.
1.0.0b1 (2020-01-09)
Version (1.0.0b1) is the first preview of our efforts to create a user-friendly and Pythonic client library for Azure Text Analytics. For more information about this, and preview releases of other Azure SDK libraries, please visit
https://azure.github.io/azure-sdk/releases/latest/python.html.
Breaking changes: New API design
-
New namespace/package name:
- The namespace/package name for Azure Text Analytics client library has changed from
azure.cognitiveservices.language.textanalytics
to azure.ai.textanalytics
-
New operations and naming:
detect_language
is renamed to detect_languages
entities
is renamed to recognize_entities
key_phrases
is renamed to extract_key_phrases
sentiment
is renamed to analyze_sentiment
- New operation
recognize_pii_entities
finds personally identifiable information entities in text - New operation
recognize_linked_entities
provides links from a well-known knowledge base for each recognized entity - New module-level operations
single_detect_language
, single_recognize_entities
, single_extract_key_phrases
, single_analyze_sentiment
, single_recognize_pii_entities
, and single_recognize_linked_entities
perform
function on a single string instead of a batch of text documents and can be imported from the azure.ai.textanalytics
namespace. - New client and module-level async APIs added to subnamespace
azure.ai.textanalytics.aio
. MultiLanguageInput
has been renamed to TextDocumentInput
LanguageInput
has been renamed to DetectLanguageInput
DocumentLanguage
has been renamed to DetectLanguageResult
DocumentEntities
has been renamed to RecognizeEntitiesResult
DocumentLinkedEntities
has been renamed to RecognizeLinkedEntitiesResult
DocumentKeyPhrases
has been renamed to ExtractKeyPhrasesResult
DocumentSentiment
has been renamed to AnalyzeSentimentResult
DocumentStatistics
has been renamed to TextDocumentStatistics
RequestStatistics
has been renamed to TextDocumentBatchStatistics
Entity
has been renamed to NamedEntity
Match
has been renamed to LinkedEntityMatch
- The batching methods'
documents
parameter has been renamed inputs
-
New input types:
detect_languages
can take as input a list[DetectLanguageInput]
or a list[str]
. A list of dict-like objects in the same shape as DetectLanguageInput
is still accepted as input.recognize_entities
, recognize_pii_entities
, recognize_linked_entities
, extract_key_phrases
, analyze_sentiment
can take as input a list[TextDocumentInput]
or list[str]
.
A list of dict-like objects in the same shape as TextDocumentInput
is still accepted as input.
-
New parameters/keyword arguments:
- All operations now take a keyword argument
model_version
which allows the user to specify a string referencing the desired model version to be used for analysis. If no string specified, it will default to the latest, non-preview version. detect_languages
now takes a parameter country_hint
which allows you to specify the country hint for the entire batch. Any per-item country hints will take precedence over a whole batch hint.recognize_entities
, recognize_pii_entities
, recognize_linked_entities
, extract_key_phrases
, analyze_sentiment
now take a parameter language
which allows you to specify the language for the entire batch.
Any per-item specified language will take precedence over a whole batch hint.- A
default_country_hint
or default_language
keyword argument can be passed at client instantiation to set the default values for all operations. - A
response_hook
keyword argument can be passed with a callback to use the raw response from the service. Additionally, values returned for TextDocumentBatchStatistics
and model_version
used must be retrieved using a response hook. show_stats
and model_version
parameters move to keyword only arguments.
-
New return types
- The return types for the batching methods (
detect_languages
, recognize_entities
, recognize_pii_entities
, recognize_linked_entities
, extract_key_phrases
, analyze_sentiment
) now return a heterogeneous list of
result objects and document errors in the order passed in with the request. To iterate over the list and filter for result or error, a boolean property on each object called is_error
can be used to determine whether the returned response object at
that index is a result or an error: detect_languages
now returns a List[Union[DetectLanguageResult
, DocumentError
]]recognize_entities
now returns a List[Union[RecognizeEntitiesResult
, DocumentError
]]recognize_pii_entities
now returns a List[Union[RecognizePiiEntitiesResult
, DocumentError
]]recognize_linked_entities
now returns a List[Union[RecognizeLinkedEntitiesResult
, DocumentError
]]extract_key_phrases
now returns a List[Union[ExtractKeyPhrasesResult
, DocumentError
]]analyze_sentiment
now returns a List[Union[AnalyzeSentimentResult
, DocumentError
]]- The module-level, single text operations will return a single result object or raise the error found on the document:
single_detect_languages
returns a DetectLanguageResult
single_recognize_entities
returns a RecognizeEntitiesResult
single_recognize_pii_entities
returns a RecognizePiiEntitiesResult
single_recognize_linked_entities
returns a RecognizeLinkedEntitiesResult
single_extract_key_phrases
returns a ExtractKeyPhrasesResult
single_analyze_sentiment
returns a AnalyzeSentimentResult
-
New underlying REST pipeline implementation, based on the new azure-core
library.
-
Client and pipeline configuration is now available via keyword arguments at both the client level, and per-operation. See README for a full list of optional configuration arguments.
-
Authentication using azure-identity
credentials
-
New error hierarchy:
- All service errors will now use the base type:
azure.core.exceptions.HttpResponseError
- There is one exception type derived from this base type for authentication errors:
ClientAuthenticationError
: Authentication failed.
0.2.0 (2019-03-12)
Features
- Client class can be used as a context manager to keep the underlying HTTP session open for performance
- New method "entities"
- Model KeyPhraseBatchResultItem has a new parameter statistics
- Model KeyPhraseBatchResult has a new parameter statistics
- Model LanguageBatchResult has a new parameter statistics
- Model LanguageBatchResultItem has a new parameter statistics
- Model SentimentBatchResult has a new parameter statistics
Breaking changes
- TextAnalyticsAPI main client has been renamed TextAnalyticsClient
- TextAnalyticsClient parameter is no longer a region but a complete endpoint
General Breaking changes
This version uses a next-generation code generator that might introduce breaking changes.
-
Model signatures now use only keyword-argument syntax. All positional arguments must be re-written as keyword-arguments.
To keep auto-completion in most cases, models are now generated for Python 2 and Python 3. Python 3 uses the "*" syntax for keyword-only arguments.
-
Enum types now use the "str" mixin (class AzureEnum(str, Enum)) to improve the behavior when unrecognized enum values are encountered.
While this is not a breaking change, the distinctions are important, and are documented here:
https://docs.python.org/3/library/enum.html#others
At a glance:
- "is" should not be used at all.
- "format" will return the string value, where "%s" string formatting will return
NameOfEnum.stringvalue
. Format syntax should be preferred.
Bugfixes
- Compatibility of the sdist with wheel 0.31.0
0.1.0 (2018-01-12)