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

• Python 3.7 later is required to use this package.
• You must have anAzure subscription and aCognitive Services or Language service resource to use this package.

Create a Cognitive Services or Language service resource

The Language service supports bothmulti-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 theAzure Portal orAzure CLI following the steps inthis document.

Interaction with the service using the client library begins with aclient.To create a client object, you will need the Cognitive Services or Language serviceendpoint toyour resource and acredential that allows you access:

from azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientcredential = 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 withpip:

pip install azure-ai-textanalytics

import osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]key = os.environ["AZURE_LANGUAGE_KEY"]text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))

Note that5.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 is2023-04-01.

This table shows the relationship between SDK versions and supported API versions of the service

API version can be selected by passing theapi_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 theAzure PortalorAzure CLI:

# Get the endpoint for the Language service resourceaz cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Get the API Key

You can get theAPI key from the Cognitive Services or Language service resource in theAzure Portal.Alternatively, you can useAzure 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 ofAzureKeyCredential. Use the key as the credential parameterto authenticate the client:

import osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 anAzure Active Directory (AAD) token credential,provide an instance of the desired credential type obtained from theazure-identity library.Note that regional endpoints do not support AAD authentication. Create acustom subdomainname for your resource in order to use this type of authentication.

Authentication with AAD requires some initial setup:

• Install azure-identity
• Register a new AAD application
• Grant access to the Language service by assigning the"Cognitive Services Language Reader" role to your service principal.

After setup, you can choose which type ofcredential from azure.identity to use.As an example,DefaultAzureCredentialcan 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 osfrom azure.ai.textanalytics import TextAnalyticsClientfrom azure.identity import DefaultAzureCredentialendpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]credential = DefaultAzureCredential()text_analytics_client = TextAnalyticsClient(endpoint, credential=credential)

Key concepts

TextAnalyticsClient

The Text Analytics client library provides aTextAnalyticsClient to do analysis onbatches 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

Adocument is a single unit to be analyzed by the predictive models in the Language service.The input for each operation is passed as alist 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 documentid orlanguage/country_hint, they can be passed as a list ofDetectLanguageInput orTextDocumentInputor 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!"},]

Seeservice 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.

Aresult, such asAnalyzeSentimentResult,is the result of a text analysis operation and contains a prediction or predictions about a document input.

Theerror object,DocumentError, indicates that the service had trouble processing the document and containsthe reason it was unsuccessful.

Document Error Handling

You can filter for a result or error object in the list by using theis_error attribute. For a result object this is alwaysFalse and for aDocumentError this isTrue.

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 thekind 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 hassucceeded, to get the result.

Methods that support healthcare analysis, custom text analysis, or multiple analyses are modeled as long-running operations.The client exposes abegin_<method-name> method that returns a poller object. Callers should waitfor the operation to complete by callingresult() on the poller object returned from thebegin_<method-name> method.Sample code snippets are provided to illustrate using long-running operationsbelow.

Examples

The following section provides several code snippets covering some of the most common Language service tasks, including:

• Analyze Sentiment
• Recognize Entities
• Recognize Linked Entities
• Recognize PII Entities
• Extract Key Phrases
• Detect Language
• Healthcare Entities Analysis
• Multiple Analysis
• Custom Entity Recognition
• Custom Single Label Classification
• Custom Multi Label Classification
• Extractive Summarization
• Abstractive Summarization

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 osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 ofsentiment 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, seehere.

Recognize Entities

recognize_entities recognizes and categories entities in its input text as people, places, organizations, date/time, quantities, percentages, currencies, and more.

import osimport typingfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 ofnamed entity recognitionandsupported 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 theRoman god of war). Recognized entities are associated with URLs to a well-known knowledge base, like Wikipedia.

import osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 ofentity linkingandsupported types.

Recognize PII Entities

recognize_pii_entities recognizes and categorizes Personally Identifiable Information (PII) entities in its input text, such asSocial Security Numbers, bank account information, credit card numbers, and more.

import osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 forsupported PII entity types.

Note: The Recognize PII Entities service is available in API version v3.1 and newer.

Extract Key Phrases

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 osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 ofkey phrase extraction.

Detect Language

detect_language determines the language of its input text, including the confidence score of the predicted language.

import osfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClientendpoint = 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 oflanguage detectionandlanguage and regional support.

Healthcare Entities Analysis

Long-running operationbegin_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 osimport typingfrom azure.core.credentials import AzureKeyCredentialfrom azure.ai.textanalytics import TextAnalyticsClient, HealthcareEntityRelationendpoint = 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 operationbegin_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 osfrom azure.core.credentials import AzureKeyCredentialfrom 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-corereference documentationdescribes available configurations for retries, logging, transport protocols, and more.

Troubleshooting

General

The Text Analytics client will raise exceptions defined inAzure Core.

Logging

This library uses the standardlogging library for logging.Basic information about HTTP sessions (URLs, headers, etc.) is logged at INFOlevel.

Detailed DEBUG level logging, including request/response bodies and unredactedheaders, can be enabled on a client with thelogging_enable keyword argument:

import sysimport loggingfrom azure.identity import DefaultAzureCredentialfrom azure.ai.textanalytics import TextAnalyticsClient# Create a logger for the 'azure' SDKlogger = logging.getLogger('azure')logger.setLevel(logging.DEBUG)# Configure a console outputhandler = logging.StreamHandler(stream=sys.stdout)logger.addHandler(handler)endpoint = "https://<resource-name>.cognitiveservices.azure.com/"credential = DefaultAzureCredential()# This client will log detailed information about its HTTP sessions, at DEBUG leveltext_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 fromazure-identity:

• sample_authentication.py (async version)

Common scenarios

• Analyze sentiment:sample_analyze_sentiment.py (async version)
• Recognize entities:sample_recognize_entities.py (async version)
• Recognize personally identifiable information:sample_recognize_pii_entities.py (async version)
• Recognize linked entities:sample_recognize_linked_entities.py (async version)
• Extract key phrases:sample_extract_key_phrases.py (async version)
• Detect language:sample_detect_language.py (async version)
• Healthcare Entities Analysis:sample_analyze_healthcare_entities.py (async version)
• Multiple Analysis:sample_analyze_actions.py (async version)
• Custom Entity Recognition:sample_recognize_custom_entities.py (async_version)
• Custom Single Label Classification:sample_single_label_classify.py (async_version)
• Custom Multi Label Classification:sample_multi_label_classify.py (async_version)
• Extractive text summarization:sample_extract_summary.py (async version)
• Abstractive text summarization:sample_abstract_summary.py (async version)

Advanced scenarios

• Opinion Mining:sample_analyze_sentiment_with_opinion_mining.py (async_version)

Additional documentation

For more extensive documentation on Azure Cognitive Service for Language, see theLanguage 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, visitcla.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 theMicrosoft Open Source Code of Conduct. For more information see theCode of Conduct FAQ or contactopencode@microsoft.com with any additional questions or comments.