Azure Análise de Texto biblioteca de clientes para Python - versão 5.3.0b1

O Azure Cognitive Service for Language é um serviço baseado na nuvem que fornece funcionalidades de processamento de linguagem natural (NLP) para a compreensão e análise de texto, e inclui as seguintes características principais:

  • Análise de Sentimentos
  • Reconhecimento de Entidades Nomeadas
  • Deteção de Idioma
  • Extração de Expressões-Chave
  • Ligar à Entidade
  • Análise Múltipla
  • Deteção de informação pessoalmente identificável (PII)
  • Análise de Texto para a Saúde
  • Reconhecimento de Entidades Personalizadas
  • Classificação de texto personalizado
  • Resumo do texto extrativo
  • Resumo abstrativo do texto
  • Classificação Dinâmica

Código fonte | Pacote (PyPI) | Documentação de | referência da API Documentação | do produto Amostras

Introdução

Pré-requisitos

Criar um recurso de serviço cognitivo ou de serviço de linguagem

O serviço Language suporta o acesso multi-serviço e de serviço único. Crie um recurso de Serviços Cognitivos se planeia aceder a múltiplos serviços cognitivos sob um único ponto final/tecla. Apenas para o acesso ao serviço de línguas, crie um recurso de serviço de idioma.

Pode criar o recurso utilizando

Opção 1:Portal Azure

Opção 2:Azure CLI. Abaixo está um exemplo de como pode criar um recurso de serviço de idioma usando o CLI:

# Create a new resource group to hold the Language service resource -
# if using an existing resource group, skip this step
az group create --name my-resource-group --location westus2
# Create text analytics
az cognitiveservices account create \
    --name text-analytics-resource \
    --resource-group my-resource-group \
    --kind TextAnalytics \
    --sku F0 \
    --location westus2 \
    --yes

A interação com o serviço utilizando a biblioteca do cliente começa com um cliente . Para criar um objeto de cliente, necessitará dos Serviços Cognitivos ou Serviços endpoint de Idioma ao seu recurso e de um credential que lhe permita aceder:

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 que para alguns recursos dos Serviços Cognitivos o ponto final pode parecer diferente do corte de código acima. Por exemplo, https://<region>.api.cognitive.microsoft.com/.

Instale o pacote

Instale a biblioteca cliente Azure Análise de Texto para Python com pip:

pip install azure-ai-textanalytics --pre

Note que 5.2.X e os alvos mais recentes do Serviço Cognitivo Azure para APIs linguísticos. Estas APIs incluem as funcionalidades de análise de texto e processamento de linguagem natural encontradas nas versões anteriores da biblioteca de clientes Análise de Texto. Além disso, o serviço API mudou de versão semântica para baseada em data. Esta versão da biblioteca do cliente está em incumprimento da versão API suportada mais recente, que atualmente é 2022-10-01-preview.

Esta tabela mostra a relação entre as versões SDK e as versões API suportadas do serviço

Versão do SDK Versão de serviço suportada pela API
5.3.0b1 - Mais recente versão beta 3.0, 3.1, 2022-05-01, 2022-10-01-pré-visualização (padrão)
5.2.X - Último lançamento estável 3.0, 3.1, 2022-05-01 (padrão)
5.1.0 3.0, 3.1 (padrão)
5.0.0 3.0

A versão API pode ser selecionada passando o argumento de palavras-chave api_version para o cliente. Para as mais recentes funcionalidades do serviço Language, considere selecionar a versão beta API mais recente. Para cenários de produção, recomenda-se a versão mais recente estável. A definição para uma versão mais antiga pode resultar numa compatibilidade reduzida da funcionalidade.

Autenticar o cliente

Obter o ponto final

Pode encontrar o ponto final do seu recurso de serviço idioma utilizando o Portal Azure ou O Azure CLI:

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

Obtenha a chave API

Pode obter a chave API a partir do recurso de serviço cognitivo ou de serviço de linguagem no Portal Azure. Em alternativa, pode utilizar o snippet Azure CLI abaixo para obter a chave API do seu recurso.

az cognitiveservices account keys list --name "resource-name" --resource-group "resource-group-name"

Criar um TextAnalyticsClient com uma credencial chave API

Uma vez que tenha o valor da tecla API, pode passá-la como uma corda para um exemplo de AzureKeyCredential. Utilize a chave como parâmetro de credencial para autenticar o cliente:

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)

Criar um TextAnalyticsClient com uma credencial de diretório ativo Azure

Para utilizar uma credencial de token Azure Ative(AAD), forneça uma instância do tipo credencial pretendido obtido a partir da biblioteca de identidade azul . Note que os pontos finais regionais não suportam a autenticação da AAD. Crie um nome de subdomínio personalizado para o seu recurso para utilizar este tipo de autenticação.

A autenticação com AAD requer alguma configuração inicial:

Após a configuração, pode escolher que tipo de credencial a azul.identidade a usar. Como exemplo, o DefaultAzureCredential pode ser usado para autenticar o cliente:

Decreta os valores do ID do cliente, iD do inquilino e o segredo do cliente da aplicação AAD como variáveis ambientais: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

Utilize a credencial simbólica devolvida para autenticar o cliente:

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

credential = DefaultAzureCredential()
text_analytics_client = TextAnalyticsClient(endpoint="https://<resource-name>.cognitiveservices.azure.com/", credential=credential)

Conceitos-chave

TextAnalyticsClient

A biblioteca de clientes Análise de Texto fornece um TextAnalyticsClient para fazer de lotes de documentos. Fornece operações sincronizadas e assíncronos para aceder a uma utilização específica da análise de texto, como a deteção de linguagem ou a extração de frases-chave.

Entrada

Um documento é uma única unidade a ser analisada pelos modelos preditivos no serviço Language. A entrada para cada operação é passada como uma lista de documentos.

Cada documento pode ser passado como uma corda na lista, por exemplo.

documents = ["I hated the movie. It was so slow!", "The movie made it into my top ten favorites. What a great movie!"]

ou, se desejar passar num documento id por item oulanguagecountry_hint/, podem ser aprovados como uma lista de DetectLanguageInput ou TextDocumentInput ou uma representação semelhante a um dict do objeto:

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!"},
]

Consulte as limitações de serviço para a entrada, incluindo limites de comprimento do documento, tamanho máximo do lote e codificação de texto suportado.

Devolver Valor

O valor de devolução de um único documento pode ser um objeto de resultado ou erro. Uma lista heterogénea contendo uma coleção de resultados e objetos de erro é devolvida de cada operação. Estes resultados/erros são indexados à ordem dos documentos fornecidos.

Um resultado, como o AnalyzeSentimentResult, é o resultado de uma operação de análise de texto e contém uma previsão ou previsões sobre uma entrada de documento.

O objeto de erro , DocumentError, indica que o serviço teve problemas em processar o documento e contém a razão pela qual não foi bem sucedido.

Manipulação de erros de documento

Pode filtrar para obter um objeto de resultado ou erro na lista utilizando o is_error atributo. Para um objeto de resultados isto é sempre False e para um DocumentError isto é True.

Por exemplo, para filtrar todos os DocumentErrors pode utilizar a compreensão da lista:

response = text_analytics_client.analyze_sentiment(documents)
successful_responses = [doc for doc in response if not doc.is_error]

Também pode utilizar o kind atributo para filtrar entre os tipos de resultados:

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}")

Operações Long-Running

As operações de longa duração são operações que consistem num pedido inicial enviado ao serviço para iniciar uma operação, seguida de sondagens ao serviço a intervalos para determinar se a operação foi concluída ou falhou, e se conseguiu, para obter o resultado.

Métodos que suportam a análise de cuidados de saúde, análise de texto personalizado ou múltiplas análises são modelados como operações de longa duração. O cliente expõe um begin_<method-name> método que devolve um objeto poller. Os chamadores devem esperar que a operação esteja concluída, chamando result() o objeto poller devolvido do begin_<method-name> método. Os fragmentos de código de amostra são fornecidos para ilustrar a utilização de operações de longo prazo abaixo.

Exemplos

A secção seguinte fornece vários fragmentos de código que cobrem algumas das tarefas de serviço linguístico mais comuns, incluindo:

Analisar sentimento

analyze_sentiment olha para o seu texto de entrada e determina se o seu sentimento é positivo, negativo, neutro ou misto. A sua resposta inclui análise de sentimento por frase e pontuações de confiança.

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = [
    "I did not like the restaurant. The food was somehow both too spicy and underseasoned. Additionally, I thought the location was too far away from the playhouse.",
    "The restaurant was decorated beautifully. The atmosphere was unlike any other restaurant I've been to.",
    "The food was yummy. :)"
]

response = text_analytics_client.analyze_sentiment(documents, language="en")
result = [doc for doc in response if not doc.is_error]

for doc in result:
    print(f"Overall sentiment: {doc.sentiment}")
    print(
        f"Scores: positive={doc.confidence_scores.positive}; "
        f"neutral={doc.confidence_scores.neutral}; "
        f"negative={doc.confidence_scores.negative}\n"
    )

A resposta devolvida é uma lista heterogénea de objetos de resultados e erros: lista[AnalyzeSentimentResult, DocumentError]

Por favor, consulte a documentação do serviço para uma discussão conceptual sobre a análise do sentimento. Para ver como realizar uma análise mais granular nas opiniões relacionadas com aspetos individuais (como atributos de um produto ou serviço) num texto, consulte aqui.

Reconhecer entidades

recognize_entities reconhece e categorias entidades no seu texto de entrada como pessoas, locais, organizações, data/hora, quantidades, percentagens, moedas, entre outras.

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = [
    """
    Microsoft was founded by Bill Gates and Paul Allen. Its headquarters are located in Redmond. Redmond is a
    city in King County, Washington, United States, located 15 miles east of Seattle.
    """,
    "Jeff bought three dozen eggs because there was a 50% discount."
]

response = text_analytics_client.recognize_entities(documents, language="en")
result = [doc for doc in response if not doc.is_error]

for doc in result:
    for entity in doc.entities:
        print(f"Entity: {entity.text}")
        print(f"...Category: {entity.category}")
        print(f"...Confidence Score: {entity.confidence_score}")
        print(f"...Offset: {entity.offset}")

A resposta devolvida é uma lista heterogénea de objetos de resultados e erros: lista[RecogniseEntitiesResult, DocumentError]

Consulte a documentação do serviço para uma discussão conceptual sobre o reconhecimento de entidades nomeadas e tipos suportados.

Reconhecer entidades ligadas

recognize_linked_entities reconhece e desambia a identidade de cada entidade encontrada no seu texto de entrada (por exemplo, determinando se uma ocorrência da palavra Marte se refere ao planeta, ou ao deus romano da guerra). Entidades reconhecidas estão associadas a URLs a um base de dados de conhecimento bem conhecido, como a Wikipédia.

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = [
    "Microsoft was founded by Bill Gates and Paul Allen. Its headquarters are located in Redmond.",
    "Easter Island, a Chilean territory, is a remote volcanic island in Polynesia."
]

response = text_analytics_client.recognize_linked_entities(documents, language="en")
result = [doc for doc in response if not doc.is_error]

for doc in result:
    for entity in doc.entities:
        print(f"Entity: {entity.name}")
        print(f"...URL: {entity.url}")
        print(f"...Data Source: {entity.data_source}")
        print("...Entity matches:")
        for match in entity.matches:
            print(f"......Entity match text: {match.text}")
            print(f"......Confidence Score: {match.confidence_score}")
            print(f"......Offset: {match.offset}")

A resposta devolvida é uma lista heterogénea de objetos de resultados e erros: lista[RecogniseLinkedEntitiesResult, DocumentError]

Consulte a documentação do serviço para uma discussão conceptual sobre a ligação de entidades e tipos suportados.

Reconhecer entidades pii

recognize_pii_entities reconhece e categoriza entidades de Informação Pessoalmente Identificável (PII) no seu texto de entrada, tais como Números de Segurança Social, informação de contas bancárias, números de cartões de crédito, entre outros.

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = [
    """
    We have an employee called Parker who cleans up after customers. The employee's
    SSN is 859-98-0987, and their phone number is 555-555-5555.
    """
]
response = text_analytics_client.recognize_pii_entities(documents, language="en")
result = [doc for doc in response if not doc.is_error]
for idx, doc in enumerate(result):
    print(f"Document text: {documents[idx]}")
    print(f"Redacted document text: {doc.redacted_text}")
    for entity in doc.entities:
        print(f"...Entity: {entity.text}")
        print(f"......Category: {entity.category}")
        print(f"......Confidence Score: {entity.confidence_score}")
        print(f"......Offset: {entity.offset}")

A resposta devolvida é uma lista heterogénea de objetos de resultado e erro: lista[RecognisePiiEntitiesResult, DocumentError]

Consulte a documentação de serviço para tipos de entidades PII suportados.

Nota: O serviço De Entidades PII Recognise está disponível na versão API v3.1 e mais recente.

Extrair Expressões-Chave

extract_key_phrases determina os principais pontos de conversação no seu texto de entrada. Por exemplo, para o texto de entrada "A comida era deliciosa e havia um pessoal maravilhoso", a API regressa: "comida" e "pessoal maravilhoso".

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

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. He has been sick recently, and I need to take him
    before I travel to South America for the summer.
    """,
]

response = text_analytics_client.extract_key_phrases(documents, language="en")
result = [doc for doc in response if not doc.is_error]

for doc in result:
    print(doc.key_phrases)

A resposta devolvida é uma lista heterogénea de objetos de resultado e erro: lista[ExtractKeyPhrasesResult, DocumentError]

Consulte a documentação do serviço para uma discussão conceptual sobre a extração de frases-chave.

Detetar Idioma

detect_language determina a linguagem do seu texto de entrada, incluindo a pontuação de confiança da língua prevista.

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = [
    """
    This whole document is written in English. In order for the whole document to be written
    in English, every sentence also has to be written in English, which it is.
    """,
    "Il documento scritto in italiano.",
    "Dies ist in deutsche Sprache verfasst."
]

response = text_analytics_client.detect_language(documents)
result = [doc for doc in response if not doc.is_error]

for doc in result:
    print(f"Language detected: {doc.primary_language.name}")
    print(f"ISO6391 name: {doc.primary_language.iso6391_name}")
    print(f"Confidence score: {doc.primary_language.confidence_score}\n")

A resposta devolvida é uma lista heterogénea de objetos de resultados e erros: lista[DetectLanguageResult, DocumentError]

Consulte a documentação do serviço para uma discussão conceptual sobre deteção de línguas e linguagem e apoio regional.

Análise de Entidades de Cuidados de Saúde

A operação de longa duraçãobegin_analyze_healthcare_entities extraí entidades reconhecidas no domínio dos cuidados de saúde, e identifica relações entre entidades dentro do documento de entrada e ligações a fontes de informação conhecidas em várias bases de dados bem conhecidas, tais como UMLS, CHV, MSH, etc.

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = ["Subject is taking 100mg of ibuprofen twice daily"]

poller = text_analytics_client.begin_analyze_healthcare_entities(documents)
result = poller.result()

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

print("Results of Healthcare Entities Analysis:")
for idx, doc in enumerate(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("------------------------------------------")

Nota: Análise de Entidades de Cuidados de Saúde Só está disponível com a versão API v3.1 e mais recente.

Análise Múltipla

A operação de longa duraçãobegin_analyze_actions executa múltiplas análises sobre um conjunto de documentos num único pedido. Atualmente é suportado utilizando qualquer combinação das seguintes APIs linguísticas num único pedido:

  • Reconhecimento de Entidades
  • Reconhecimento de Entidades PII
  • Reconhecimento de Entidades Ligadas
  • Extração de Expressões-Chave
  • Análise de Sentimentos
  • Reconhecimento de Entidades Personalizadas (versão API 2022-05-01 e mais recente)
  • Classificação personalizada de rótulo único (versão API 2022-05-01 e mais recente)
  • Classificação personalizada de vários rótulos (versão API 2022-05-01 e mais recente)
  • Análise de Entidades de Cuidados de Saúde (versão API 2022-05-01 e mais recente)
  • Resumo Extrativo (versão API 2022-10-01-pré-visualização e mais recente)
  • Resumo Abstrativo (versão API 2022-10-01-pré-visualização e mais recente)
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import (
    TextAnalyticsClient,
    RecognizeEntitiesAction,
    AnalyzeSentimentAction,
)

credential = AzureKeyCredential("<api_key>")
endpoint="https://<resource-name>.cognitiveservices.azure.com/"

text_analytics_client = TextAnalyticsClient(endpoint, credential)

documents = ["Microsoft was founded by Bill Gates and Paul Allen."]

poller = text_analytics_client.begin_analyze_actions(
    documents,
    display_name="Sample Text Analysis",
    actions=[
        RecognizeEntitiesAction(),
        AnalyzeSentimentAction()
    ]
)

# returns multiple actions results in the same order as the inputted actions
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 == "SentimentAnalysis":
            print("...Results of Analyze Sentiment action:")
            print(f"......Overall sentiment: {result.sentiment}")
            print(f"......Scores: positive={result.confidence_scores.positive}; "
                  f"neutral={result.confidence_scores.neutral}; "
                  f"negative={result.confidence_scores.negative}\n")

        elif result.is_error is True:
            print(f"......Is an error with code '{result.code}' "
                  f"and message '{result.message}'")

    print("------------------------------------------")

A resposta devolvida é um objeto que encapsula múltiplos iteráveis, cada um representando resultados de análises individuais.

Nota: A análise múltipla está disponível na versão API v3.1 e mais recente.

Configuração opcional

Os argumentos de palavras-chave opcionais podem ser transmitidos ao cliente e ao nível por operação. A documentação de referência do núcleo azul descreve as configurações disponíveis para recaídas, registos, protocolos de transporte e muito mais.

Resolução de problemas

Geral

O Análise de Texto cliente irá levantar exceções definidas no Azure Core.

Registo

Esta biblioteca utiliza a biblioteca de registos padrão para registar registos. Informações básicas sobre sessões HTTP (URLs, cabeçalhos, etc.) são registadas ao nível info.

A registo detalhado do nível DEBUG, incluindo os órgãos de pedido/resposta e os cabeçalhos não redigidos, pode ser ativado num cliente com o argumento da logging_enable palavra-chave:

import sys
import logging
from azure.identity import DefaultAzureCredential
from azure.ai.textanalytics import TextAnalyticsClient

# Create a logger for the 'azure' SDK
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)

# Configure a console output
handler = 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 level
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."])

Da mesma forma, logging_enable pode permitir a registo detalhado para uma única operação, mesmo quando não está habilitado para o cliente:

result = text_analytics_client.analyze_sentiment(documents, logging_enable=True)

Passos seguintes

Mais código de amostra

Estas amostras de código mostram operações de cenário comum com a biblioteca de clientes Azure Análise de Texto.

Autenticar o cliente com uma chave API de serviço cognitivo/serviço de linguagem ou uma credencial simbólica da identidade azul:

Cenários comuns

Cenários avançados

Documentação adicional

Para documentação mais extensa sobre o Serviço Cognitivo para a Língua do Azure, consulte a documentação do Serviço de Línguas sobre docs.microsoft.com.

Contribuir

Agradecemos todas as contribuições e sugestões para este projeto. A maioria das contribuições requerem que celebre um Contrato de Licença de Contribuição (CLA) no qual se declare que tem o direito de conceder e que, na verdade, concede-nos os direitos para utilizar a sua contribuição. Para mais detalhes, visite cla.microsoft.com.

Quando submete um pedido Pull, um bot do CLA determina automaticamente se tem de fornecer um CLA e decorar o PR de forma adequada (por exemplo, etiqueta, comentário). Só tem de seguir as instruções fornecidas pelo bot. Apenas terá de fazer isto uma vez em todos os repositórios com o nosso CLA.

Este projeto adotou o Microsoft Open Source Code of Conduct (Código de Conduta do Microsoft Open Source). Para mais informações consulte o Código de Conduta FAQ ou contacte opencode@microsoft.com com quaisquer perguntas ou comentários adicionais.