Guida introduttiva: Librerie client di Traduttore per Azure AI (anteprima)

Configurare l'ambiente C#/.NET

In questo avvio rapido si usa la versione più recente dell'IDE di Visual Studio per creare ed eseguire l'applicazione.

1. Avviare Visual Studio.

2. Nella pagina Attività iniziali scegliere Crea un nuovo progetto.

   

3. Nella pagina Crea un nuovo progetto immettere console nella casella di ricerca. Scegliere il modello Applicazione console, quindi selezionare Avanti.

   

4. Nella finestra di dialogo Configura il nuovo progetto immettere text-translation-sdk nella casella Nome progetto. Scegliere quindi Avanti.

   

5. Nella finestra di dialogo Altre informazioni assicurarsi che sia selezionata l'opzione .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.

   

Installare la libreria client con NuGet

1. Fare clic con il pulsante destro del mouse sul progetto Translator-text-sdk e selezionare Gestisci pacchetti NuGet...

2. Selezionare la scheda Sfoglia e la casella di controllo Includi versione preliminare, quindi digitare Azure.AI.Translation.Text.

   

3. Selezionare la versione 1.0.0-beta.1 dal menu a discesa e installare il pacchetto nel progetto.

   

Compilare l'applicazione

Per interagire con il servizio Traduttore usando la libreria client, è necessario creare un'istanza della classe TextTranslationClient. A tale scopo, creare un oggetto AzureKeyCredential con la key del portale di Azure e un'istanza TextTranslationClient con AzureKeyCredential. L'autenticazione varia leggermente a seconda che la risorsa usi l'endpoint globale o a livello di area. Per questo progetto, eseguire l'autenticazione usando l'endpoint globale. Per altre informazioni sull'uso di un endpoint a livello di area, vedereSDK di Traduttore testuale.

1. Aprire il file Program.cs.

2. Eliminare il codice preesistente, inclusa la riga Console.WriteLine("Hello World!"), e immettere l'esempio di codice seguente nel file Program.cs dell'applicazione:

Esempio di codice

Tradurre un testo

using Azure;
using Azure.AI.Translation.Text;


string key = "<your-key>";

AzureKeyCredential credential = new(key);
TextTranslationClient client = new(credential);

try
{
    string targetLanguage = "fr";
    string inputText = "This is a test.";

    Response<IReadOnlyList<TranslatedTextItem>> response = await client.TranslateAsync(targetLanguage, inputText).ConfigureAwait(false);
    IReadOnlyList<TranslatedTextItem> translations = response.Value;
    TranslatedTextItem translation = translations.FirstOrDefault();

    Console.WriteLine($"Detected languages of the input text: {translation?.DetectedLanguage?.Language} with score: {translation?.DetectedLanguage?.Score}.");
    Console.WriteLine($"Text was translated to: '{translation?.Translations?.FirstOrDefault().To}' and the result is: '{translation?.Translations?.FirstOrDefault()?.Text}'.");
}
catch (RequestFailedException exception)
{
    Console.WriteLine($"Error Code: {exception.ErrorCode}");
    Console.WriteLine($"Message: {exception.Message}");
}

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, scegliere il pulsante verde di avvio accanto a formRecognizer_quickstart per compilare ed eseguire il programma oppure premere F5.

Ecco un frammento di output previsto:

Configurare l'ambiente Java

In questo avvio rapido si usa lo strumento di automazione della compilazione Gradle per creare ed eseguire l'applicazione.

• È necessario avere la versione più recente di Visual Studio Code o l'IDE preferito. Vedere Java in Visual Studio Code.

  Suggerimento

  • Visual Studio Code offre un Coding Pack per Java per Windows e macOS. Il Coding Pack è un bundle di VS Code, Java Development Kit (JDK) e una raccolta di estensioni suggerite da Microsoft. Il Coding Pack può essere usato anche per correggere un ambiente di sviluppo esistente.
  • Se si usano VS Code e Coding Pack per Java, installare l'estensione Gradle per Java.

• Se non si usa Visual Studio Code, assicurarsi di avere installato quanto segue nell'ambiente di sviluppo:

  • Un Java Development Kit (OpenJDK) versione 8 o successiva.

  • Gradle, versione 6.8 o successiva.

Creare un nuovo progetto Gradle

1. In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app denominata text-translation-app.

   mkdir text-translation-app && text-translation-app
   

   mkdir text-translation-app; cd text-translation-app
   

2. Eseguire il comando gradle init dalla directory text-translation-app. Questo comando crea i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene usato in fase di esecuzione per creare e configurare l'applicazione.

   gradle init --type basic
   

3. Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

4. Accettare il nome del progetto predefinito (text-translation-app) selezionando Torna o Invio.

   Nota

   La creazione dell'intera applicazione potrebbe richiedere alcuni minuti, ma presto verranno visualizzati diversi file e cartelle, tra cui build-gradle.kts.

5. Aggiornare build.gradle.kts con il codice seguente. La classe principale è Translate:

     plugins {
     java
     application
   }
   application {
     mainClass.set("Translate")
   }
   repositories {
     mavenCentral()
   }
   dependencies {
     implementation("com.azure:azure-ai-translation-text:1.0.0-beta.1")
   }
   

Creare l'applicazione Java

1. Dalla directory text-translation-app eseguire il comando seguente:

   mkdir -p src/main/java
   

   Il comando crea la struttura di directory seguente:

   

2. Passare alla directory java e creare un file denominato Translate.java.

   Suggerimento

   • È possibile creare un nuovo file usando PowerShell.

   • Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.

   • Immettere il comando New-Item Translate.java.

   • È anche possibile creare un nuovo file nell'IDE denominato Translate.java e salvarlo nella directory java.

3. Copiare e incollare l'esempio di codice di traduzione testuale seguente nel file Translate.java.

   • Aggiornare "<your-key>", "<your-endpoint>" e "<region>" con i valori dell'istanza di Traduttore del portale di Azure.

Esempio di codice

Tradurre un testo

Per interagire con il servizio Traduttore usando la libreria client, è necessario creare un'istanza della classe TextTranslationClient. A tale scopo, creare un oggetto AzureKeyCredential con la key del portale di Azure e un'istanza TextTranslationClient con AzureKeyCredential. L'autenticazione varia leggermente a seconda che la risorsa usi l'endpoint globale o a livello di area. Per questo progetto, eseguire l'autenticazione usando l'endpoint globale. Per altre informazioni sull'uso di un endpoint a livello di area, vedereSDK di Traduttore testuale.

import java.util.List;
import java.util.ArrayList;
import com.azure.ai.translation.text.models.*;
import com.azure.ai.translation.text.TextTranslationClientBuilder;
import com.azure.ai.translation.text.TextTranslationClient;

import com.azure.core.credential.AzureKeyCredential;
/**
 * Translate text from known source language to target language.
 */
public class Translate {

    public static void main(String[] args) {
        String apiKey = "<your-key>";
        AzureKeyCredential credential = new AzureKeyCredential(apiKey);

        TextTranslationClient client = new TextTranslationClientBuilder()
                .credential(credential)
                .buildClient();

        String from = "en";
        List<String> targetLanguages = new ArrayList<>();
        targetLanguages.add("es");
        List<InputTextItem> content = new ArrayList<>();
        content.add(new InputTextItem("This is a test."));

        List<TranslatedTextItem> translations = client.translate(targetLanguages, content, null, from, TextType.PLAIN, null, null, null, false, false, null, null, null, false);

        for (TranslatedTextItem translation : translations) {
            for (Translation textTranslation : translation.getTranslations()) {
                System.out.println("Text was translated to: '" + textTranslation.getTo() + "' and the result is: '" + textTranslation.getText() + "'.");
            }
        }
    }
}

Compilare ed eseguire l'applicazione**

Dopo aver aggiunto l'esempio di codice all'applicazione, tornare alla directory principale del progetto,text-translation-app.

1. Compilare l'applicazione con il comando build. Verrà visualizzato il messaggio BUILD SUCCESSFUL (Compilazione riuscita):

   gradle build
   

2. Eseguire l'applicazione con il comando run. Verrà visualizzato il messaggio BUILD SUCCESSFUL (Compilazione riuscita):

   gradle run
   

Ecco un frammento di output previsto:

Configurare l'ambiente Node.js

Per questo avvio rapido si usa l'ambiente di runtime JavaScript di Node.js per creare ed eseguire l'applicazione.

1. Se non è già stato fatto, installare la versione più recente di Node.js. Node Package Manager (npm) è incluso nell'installazione Node.js.

   Suggerimento

   Se non si ha familiarità con Node.js, provare il modulo di Learn Introduzione a Node.js.

2. In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app denominata text-translation-app.

   mkdir text-translation-app && cd text-translation-app
   

   mkdir text-translation-app; cd text-translation-app
   

3. Digitare il comando npm init per inizializzare l'applicazione ed eseguire lo scaffolding del progetto.

   npm init
   

4. Specificare gli attributi del progetto accettando le richieste presentate nel terminale.

   • Gli attributi più importanti sono nome, numero di versione e punto di ingresso.
   • È consigliabile mantenere index.js per il nome del punto di ingresso. La descrizione, il comando di test, il repository GitHub, le parole chiave, l'autore e le informazioni sulla licenza sono attributi facoltativi, ma possono essere ignorati per questo progetto.
   • Accettare i suggerimenti tra parentesi selezionando Torna o Invio.
   • Dopo aver completato le richieste, nella directory text-translation-app verrà creato un file package.json.

Installare la libreria client

Aprire una finestra del terminale e installare la libreria client Azure Text Translation per JavaScript con npm:

npm i @azure-rest/ai-translation-text@1.0.0-beta.1

Compilare l'applicazione

Per interagire con il servizio Traduttore usando la libreria client, è necessario creare un'istanza della classe TextTranslationClient. A tale scopo, creare un oggetto TranslateCredential con la key e la <region> del portale di Azure e un'istanza TextTranslationClient. Per altre informazioni, vedereSDK di Traduttore testuale.

1. Creare il file index.js nella directory dell'app.

   Suggerimento

   • È possibile creare un nuovo file usando PowerShell.

   • Tenendo premuto il tasto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella, aprire una finestra di PowerShell nella directory del progetto.

   • Immettere il comando New-Item index.js.

   • È anche possibile creare un nuovo file nell'IDE denominato index.js e salvarlo nella directory text-translation-app.

2. Copiare e incollare l'esempio di codice di traduzione testuale seguente nel file index.js. Aggiornare <your-endpoint> e <your-key> con i valori dell'istanza di Traduttore del portale di Azure.

Esempio di codice

Tradurre un testo

const TextTranslationClient = require("@azure-rest/ai-translation-text").default

const apiKey = "<your-key>";
const endpoint = "<your-endpoint>";
const region = "<region>";

async function main() {

  console.log("== Text translation sample ==");

  const translateCredential = {
    key: apiKey,
    region,
  };
  const translationClient = new TextTranslationClient(endpoint,translateCredential);

  const inputText = [{ text: "This is a test." }];
  const translateResponse = await translationClient.path("/translate").post({
    body: inputText,
    queryParameters: {
      to: "fr",
      from: "en",
    },
  });

  const translations = translateResponse.body;
  for (const translation of translations) {
    console.log(
      `Text was translated to: '${translation?.translations[0]?.to}' and the result is: '${translation?.translations[0]?.text}'.`
    );
  }
}

main().catch((err) => {
    console.error("An error occurred:", err);
    process.exit(1);
  });

  module.exports = { main };

Eseguire l'applicazione

Dopo aver aggiunto l'esempio di codice all'applicazione, eseguire il programma:

1. Passare alla cartella in cui è presente l'applicazione di traduzione testuale (text-translation-app).

2. Digitare il comando seguente nel terminale:

   node index.js
   

Ecco un frammento di output previsto:

Configurare il progetto Python

1. Se non è già stato fatto, installare la versione più recente di Python 3.x. Il pacchetto del programma di installazione Python (pip) è incluso nell'installazione di Python.

   Suggerimento

   Se non si ha familiarità con Python, provare il modulo Learn Introduzione a Python.

2. Aprire una finestra del terminale e installare la libreria client Azure Text Translation per Python con pip:

   pip install azure-ai-translation-text==1.0.0b1
   

Compilare l'applicazione

Per interagire con il servizio Traduttore usando la libreria client, è necessario creare un'istanza della classe TextTranslationClient. A tale scopo, creare un oggetto TranslatorCredential con la key del portale di Azure e un'istanza TextTranslationClient. Per altre informazioni, vedereSDK di Traduttore testuale.

1. Creare un nuovo file Python denominato text-translation-app.py nell'editor o nell'IDE preferito.

2. Copiare e incollare l'esempio di codice di traduzione testuale seguente nel file text-translation-app.py. Aggiornare <your-key>, <your-endpoint> e <region> con i valori dell'istanza di Traduttore del portale di Azure.

Esempio di codice

Tradurre un testo

from azure.ai.translation.text import TextTranslationClient, TranslatorCredential
from azure.ai.translation.text.models import InputTextItem
from azure.core.exceptions import HttpResponseError

# set `<your-key>`, `<your-endpoint>`, and  `<region>` variables with the values from the Azure portal
key = "<your-key>"
endpoint = "<your-endpoint>"
region = "<region>"

credential = TranslatorCredential(key, region)
text_translator = TextTranslationClient(endpoint=endpoint, credential=credential)

try:
    source_language = "en"
    target_languages = ["es", "it"]
    input_text_elements = [ InputTextItem(text = "This is a test") ]

    response = text_translator.translate(content = input_text_elements, to = target_languages, from_parameter = source_language)
    translation = response[0] if response else None

    if translation:
        for translated_text in translation.translations:
            print(f"Text was translated to: '{translated_text.to}' and the result is: '{translated_text.text}'.")

except HttpResponseError as exception:
    print(f"Error Code: {exception.error.code}")
    print(f"Message: {exception.error.message}")

Eseguire l'applicazione

Dopo aver aggiunto l'esempio di codice all'applicazione, compilare ed eseguire il programma:

Passare alla cartella in cui è presente il file text-translation-app.py.

Digitare il comando seguente nel terminale:

python text-translation-app.py

Ecco un frammento di output previsto: