Azure AI services | Document intelligence | Use prebuilt Document Intelligence models

Azure AI services | Document intelligence | Use prebuilt Document Intelligence models

Source: https://github.com/MicrosoftLearning/mslearn-ai-document-intelligence

https://documentintelligence.ai.azure.com/studio

C# Code:

using Azure;

using Azure.AI.FormRecognizer.DocumentAnalysis;

// dotnet add package Azure.AI.FormRecognizer --version 4.1.0

// Store connection information

string endpoint = "https://sreedocumentintelligence.cognitiveservices.azure.com/";

string apiKey = "BxcKE20FOGiN8b";

Uri fileUri = new Uri("https://github.com/MicrosoftLearning/mslearn-ai-document-intelligence/blob

/main/Labfiles/01-prebuild-models/sample-invoice/sample-invoice.pdf?raw=true");

Console.WriteLine("\nConnecting to Forms Recognizer at: {0}", endpoint);

Console.WriteLine("Analyzing invoice at: {0}\n", fileUri.ToString());

// Create the client

var cred = new AzureKeyCredential(apiKey);

var client = new DocumentAnalysisClient(new Uri(endpoint), cred);

// Analyze the invoice

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed,

"prebuilt-invoice", fileUri);

// Display invoice information to the user

AnalyzeResult result = operation.Value;

foreach (AnalyzedDocument invoice in result.Documents)

{

    if (invoice.Fields.TryGetValue("VendorName", out DocumentField? vendorNameField))

    {

        if (vendorNameField.FieldType == DocumentFieldType.String)

        {

            string vendorName = vendorNameField.Value.AsString();

            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence

            {vendorNameField.Confidence}.");

        }

    }

    if (invoice.Fields.TryGetValue("CustomerName", out DocumentField? customerNameField))

    {

        if (customerNameField.FieldType == DocumentFieldType.String)

        {

            string customerName = customerNameField.Value.AsString();

            Console.WriteLine($"Customer Name: '{customerName}', with confidence

            {customerNameField.Confidence}.");

        }

    }

    if (invoice.Fields.TryGetValue("InvoiceTotal", out DocumentField? invoiceTotalField))

    {

        if (invoiceTotalField.FieldType == DocumentFieldType.Currency)

        {

            CurrencyValue invoiceTotal = invoiceTotalField.Value.AsCurrency();

            Console.WriteLine($"Invoice Total: '{invoiceTotal.Symbol}{invoiceTotal.Amount}',

            with confidence {invoiceTotalField.Confidence}.");

        }

    }

}

Console.WriteLine("\nAnalysis complete.\n");

OutPut:

Python Code:

from azure.core.credentials import AzureKeyCredential

from azure.ai.formrecognizer import DocumentAnalysisClient

# pip install azure-ai-formrecognizer==3.3.3

# Store connection information

endpoint = "https://sreedocumentintelligence.cognitiveservices.azure.com/"

key = "BxcKE20FOGiN8b"

fileUri = "https://github.com/MicrosoftLearning/mslearn-ai-document-intelligence/blob/main/Labfiles

/01-prebuild-models/sample-invoice/sample-invoice.pdf?raw=true"

fileLocale = "en-US"

fileModelId = "prebuilt-invoice"

print(f"\nConnecting to Forms Recognizer at: {endpoint}")

print(f"Analyzing invoice at: {fileUri}")

# Create the client

document_analysis_client = DocumentAnalysisClient(

     endpoint=endpoint, credential=AzureKeyCredential(key)

)

# Analyse the invoice

poller = document_analysis_client.begin_analyze_document_from_url(

     fileModelId, fileUri, locale=fileLocale

)

# Display invoice information to the user

receipts = poller.result()

   

for idx, receipt in enumerate(receipts.documents):

    vendor_name = receipt.fields.get("VendorName")

    if vendor_name:

        print(f"\nVendor Name: {vendor_name.value}, with confidence {vendor_name.confidence}.")

    customer_name = receipt.fields.get("CustomerName")

    if customer_name:

        print(f"Customer Name: '{customer_name.value}, with confidence {customer_name.confidence}.")

    invoice_total = receipt.fields.get("InvoiceTotal")

    if invoice_total:

        print(f"Invoice Total: '{invoice_total.value.symbol}{invoice_total.value.amount},

        with confidence {invoice_total.confidence}.")

print("\nAnalysis complete.\n")

OutPut:

Azure AI services - Detect and Analyze Faces

Azure AI services - Detect and Analyze Faces:

Source: https://github.com/MicrosoftLearning/mslearn-ai-vision

1. Azure AI services multi-service account - Create Azure resource.

Detect Faces:

C# Code:

using System;

using System.Drawing;

using Microsoft.Extensions.Configuration;

using Azure;

using System.IO;

// dotnet add package Azure.AI.Vision.ImageAnalysis -v 1.0.0-beta.3

// Import namespaces

using Azure.AI.Vision.ImageAnalysis;

namespace detect_people

{

    class Program

    {

        static void Main(string[] args)

        {

            try

            {

                // Get config settings from AppSettings

                IConfigurationBuilder builder =

                new ConfigurationBuilder().AddJsonFile("appsettings.json");

                IConfigurationRoot configuration = builder.Build();

                string aiSvcEndpoint =

                "https://sreemultiserviceaccount1.cognitiveservices.azure.com/";

                //configuration["AIServicesEndpoint"];

                string aiSvcKey = "2D9XtWQ0Yfuw3AAAEACOGFMV1"; //configuration["AIServiceKey"];

                // Get image

                string imageFile = "images/people.jpg";

                if (args.Length > 0)

                {

                    imageFile = args[0];

                }

                // Authenticate Azure AI Vision client

                ImageAnalysisClient cvClient = new ImageAnalysisClient(

                    new Uri(aiSvcEndpoint),

                    new AzureKeyCredential(aiSvcKey));

                // Analyze image

                AnalyzeImage(imageFile, cvClient);

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message);

            }

        }

        static void AnalyzeImage(string imageFile, ImageAnalysisClient client)

        {

            Console.WriteLine($"\nAnalyzing {imageFile} \n");

            // Use a file stream to pass the image data to the analyze call

            using FileStream stream = new FileStream(imageFile, FileMode.Open);

            // Get result with specified features to be retrieved (PEOPLE)

            ImageAnalysisResult result = client.Analyze(

                BinaryData.FromStream(stream),

                VisualFeatures.People);

            // Close the stream

            stream.Close();

            // Get people in the image

            if (result.People.Values.Count > 0)

            {

                Console.WriteLine($" People:");

                // Prepare image for drawing

                System.Drawing.Image image = System.Drawing.Image.FromFile(imageFile);

                Graphics graphics = Graphics.FromImage(image);

                Pen pen = new Pen(Color.Cyan, 3);

                // Draw bounding box around detected people

                foreach (DetectedPerson person in result.People.Values)

                {

                    if (person.Confidence > 0.5)

                    {

                        // Draw object bounding box

                        var r = person.BoundingBox;

                        Rectangle rect = new Rectangle(r.X, r.Y, r.Width, r.Height);

                        graphics.DrawRectangle(pen, rect);

                    }

                    // Return the confidence of the person detected

                    Console.WriteLine($"   Bounding box {person.BoundingBox.ToString()},

                    Confidence: {person.Confidence:F2}");

                }

                // Save annotated image

                String output_file = "people.jpg";

                image.Save(output_file);

                Console.WriteLine("  Results saved in " + output_file + "\n");

            }

        }

    }

}

OutPut:

Analyze Faces:

C# Code:

using System;

using System.IO;

using System.Linq;

using System.Drawing;

using System.Collections.Generic;

using System.Threading.Tasks;

using Microsoft.Extensions.Configuration;

// dotnet add package Azure.AI.Vision.Face -v 1.0.0-beta.2

// Import namespaces

using Azure;

using Azure.AI.Vision.Face;

namespace analyze_faces

{

    class Program

    {

        private static FaceClient faceClient;

        static async Task Main(string[] args)

        {

            try

            {

                // Get config settings from AppSettings

                IConfigurationBuilder builder =

                new ConfigurationBuilder().AddJsonFile("appsettings.json");

                IConfigurationRoot configuration = builder.Build();

                string cogSvcEndpoint =

                "https://sreemultiserviceaccount1.cognitiveservices.azure.com/";

                //configuration["AIServicesEndpoint"];

                string cogSvcKey = "2D9XtWQ0Yfuw3AAAEACOGFMV1"; //configuration["AIServiceKey"];

                // Authenticate Face client

                faceClient = new FaceClient(

                    new Uri(cogSvcEndpoint),

                    new AzureKeyCredential(cogSvcKey));

                // Menu for face functions

                Console.WriteLine("1: Detect faces\nAny other key to quit");

                Console.WriteLine("Enter a number:");

                string command = Console.ReadLine();

                switch (command)

                {

                    case "1":

                        await DetectFaces("images/people.jpg");

                        break;

                    default:

                        break;

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message);

            }

        }

        static async Task DetectFaces(string imageFile)

        {

            Console.WriteLine($"Detecting faces in {imageFile}");

            // Specify facial features to be retrieved

            FaceAttributeType[] features = new FaceAttributeType[]

            {

     FaceAttributeType.Detection03.HeadPose,

     FaceAttributeType.Detection03.Blur,

     FaceAttributeType.Detection03.Mask

            };

            // Get faces

            using (var imageData = File.OpenRead(imageFile))

            {

                var response = await faceClient.DetectAsync(

                    BinaryData.FromStream(imageData),

                    FaceDetectionModel.Detection03,

                    FaceRecognitionModel.Recognition04,

                    returnFaceId: false,

                    returnFaceAttributes: features);

                IReadOnlyList<FaceDetectionResult> detected_faces = response.Value;

                if (detected_faces.Count() > 0)

                {

                    Console.WriteLine($"{detected_faces.Count()} faces detected.");

                    // Prepare image for drawing

                    Image image = Image.FromFile(imageFile);

                    Graphics graphics = Graphics.FromImage(image);

                    Pen pen = new Pen(Color.LightGreen, 3);

                    Font font = new Font("Arial", 4);

                    SolidBrush brush = new SolidBrush(Color.White);

                    int faceCount = 0;

                    // Draw and annotate each face

                    foreach (var face in detected_faces)

                    {

                        faceCount++;

                        Console.WriteLine($"\nFace number {faceCount}");

                        // Get face properties

                        Console.WriteLine($" - Head Pose (Yaw): {face.FaceAttributes.HeadPose.Yaw}");

                        Console.WriteLine($" - Head Pose (Pitch):

                        {face.FaceAttributes.HeadPose.Pitch}");

                        Console.WriteLine($" - Head Pose (Roll):

                        {face.FaceAttributes.HeadPose.Roll}");

                        Console.WriteLine($" - Blur: {face.FaceAttributes.Blur.BlurLevel}");

                        Console.WriteLine($" - Mask: {face.FaceAttributes.Mask.Type}");

                        // Draw and annotate face

                        var r = face.FaceRectangle;

                        Rectangle rect = new Rectangle(r.Left, r.Top, r.Width, r.Height);

                        graphics.DrawRectangle(pen, rect);

                        string annotation = $"Face number {faceCount}";

                        graphics.DrawString(annotation, font, brush, r.Left, r.Top);

                    }

                    // Save annotated image

                    String output_file = "detected_faces.jpg";

                    image.Save(output_file);

                    Console.WriteLine(" Results saved in " + output_file);

                }

            }

        }

    }

}

OutPut:

Detect Faces:

Python Code:

from dotenv import load_dotenv

import os

from PIL import Image, ImageDraw

import sys

from matplotlib import pyplot as plt

import numpy as np

#pip install azure-ai-vision-imageanalysis==1.0.0b3

# import namespaces

from azure.ai.vision.imageanalysis import ImageAnalysisClient

from azure.ai.vision.imageanalysis.models import VisualFeatures

from azure.core.credentials import AzureKeyCredential

def main():

    global cv_client

    try:

        # Get Configuration Settings

        load_dotenv()

        ai_endpoint = 'https://sreemultiserviceaccount1.cognitiveservices.azure.com/'           #os.getenv('AI_SERVICE_ENDPOINT')

        ai_key = '2D9XtWQ0Yfuw3AAAEACOGFMV1' #os.getenv('AI_SERVICE_KEY')

        # Get image

        image_file = 'images/people.jpg'

        if len(sys.argv) > 1:

            image_file = sys.argv[1]

        with open(image_file, "rb") as f:

            image_data = f.read()

         # Authenticate Azure AI Vision client

        cv_client = ImageAnalysisClient(

            endpoint=ai_endpoint,

            credential=AzureKeyCredential(ai_key)

        )

       

        # Analyze image

        AnalyzeImage(image_file, image_data, cv_client)

    except Exception as ex:

        print(ex)

def AnalyzeImage(filename, image_data, cv_client):

    print('\nAnalyzing ', filename)

     # Get result with specified features to be retrieved (PEOPLE)

    result = cv_client.analyze(

         image_data=image_data,

        visual_features=[

             VisualFeatures.PEOPLE],

    )

   

    # Identify people in the image

    if result.people is not None:

        print("\nPeople in image:")

        # Prepare image for drawing

        image = Image.open(filename)

        fig = plt.figure(figsize=(image.width/100, image.height/100))

        plt.axis('off')

        draw = ImageDraw.Draw(image)

        color = 'cyan'

         # Draw bounding box around detected people

        for detected_people in result.people.list:

            if(detected_people.confidence > 0.5):

                 # Draw object bounding box

                r = detected_people.bounding_box

                bounding_box = ((r.x, r.y), (r.x + r.width, r.y + r.height))

                draw.rectangle(bounding_box, outline=color, width=3)

                # Return the confidence of the person detected

                print(" {} (confidence: {:.2f}%)".format(detected_people.bounding_box,

                detected_people.confidence * 100))

        # Save annotated image

        plt.imshow(image)

        plt.tight_layout(pad=0)

        outputfile = 'people.jpg'

        fig.savefig(outputfile)

        print('  Results saved in', outputfile)

if __name__ == "__main__":

    main()

OutPut:

Analyze Faces:

Python Code:

from dotenv import load_dotenv

import os

from PIL import Image, ImageDraw

from matplotlib import pyplot as plt

#pip install azure-cognitiveservices-vision-face==0.6.0

# Import namespaces

from azure.cognitiveservices.vision.face import FaceClient

from azure.cognitiveservices.vision.face.models import FaceAttributeType

from msrest.authentication import CognitiveServicesCredentials

def main():

    global face_client

    try:

        # Get Configuration Settings

        load_dotenv()

        # cog_endpoint = os.getenv('AI_SERVICE_ENDPOINT')

        # cog_key = os.getenv('AI_SERVICE_KEY')

       

        cog_endpoint = 'https://sreemultiserviceaccount1.cognitiveservices.azure.com/'

        cog_key ='2D9XtWQ0Yfuw3AAAEACOGFMV1'

        # Authenticate Face client

        credentials = CognitiveServicesCredentials(cog_key)

        face_client = FaceClient(cog_endpoint, credentials)

        # Menu for face functions

        print('1: Detect faces\nAny other key to quit')

        command = input('Enter a number:')

        if command == '1':

            DetectFaces(os.path.join('images','people.jpg'))

    except Exception as ex:

        print(ex)

def DetectFaces(image_file):

    print('Detecting faces in', image_file)

    # Specify facial features to be retrieved

    features = [

        FaceAttributeType.occlusion,

        FaceAttributeType.blur,

        FaceAttributeType.glasses

    ]

    # Get faces

    with open(image_file, mode="rb") as image_data:

        detected_faces = face_client.face.detect_with_stream(

        image=image_data,

        return_face_attributes=features,

        return_face_id=False

    )

    if len(detected_faces) > 0:

        print(len(detected_faces), 'faces detected.')

        # Prepare image for drawing

        fig = plt.figure(figsize=(8, 6))

        plt.axis('off')

        image = Image.open(image_file)

        draw = ImageDraw.Draw(image)

        color = 'lightgreen'

        face_count = 0

        # Draw and annotate each face

        for face in detected_faces:

            # Get face properties

            face_count += 1

            print('\nFace number {}'.format(face_count))

            detected_attributes = face.face_attributes.as_dict()

            if 'blur' in detected_attributes:

                print(' - Blur:')

                for blur_name in detected_attributes['blur']:

                    print('   - {}: {}'.format(blur_name, detected_attributes['blur'][blur_name]))

            if 'occlusion' in detected_attributes:

                print(' - Occlusion:')

                for occlusion_name in detected_attributes['occlusion']:

                    print('   - {}: {}'.format(occlusion_name,                         detected_attributes['occlusion'][occlusion_name]))

            if 'glasses' in detected_attributes:

                print(' - Glasses: {}'.format(detected_attributes['glasses']))

            # Draw and annotate face

            r = face.face_rectangle

            bounding_box = ((r.left, r.top), (r.left + r.width, r.top + r.height))

            draw.rectangle(bounding_box, outline=color, width=5)

            annotation = 'Face number {}'.format(face_count)

            plt.annotate(annotation, (r.left, r.top), backgroundcolor=color)

        # Save annotated image

        plt.imshow(image)

        outputfile = 'detected_faces.jpg'

        fig.savefig(outputfile)

        print('\nResults saved in', outputfile)

if __name__ == "__main__":

    main()

OutPut:

Azure AI services - Speech service

 Azure AI services - Speech service

Source: https://github.com/MicrosoftLearning/mslearn-ai-language

1. Create 'Speech service' in Azure - copy key and region

C# Code:

dotnet add package Microsoft.CognitiveServices.Speech --version 1.30.0

dotnet add package System.Windows.Extensions --version 4.6.0 

using System;

using System.Threading.Tasks;

using Microsoft.Extensions.Configuration;

using System.Collections.Generic;

using System.Text;

// Import namespaces

using Microsoft.CognitiveServices.Speech;

using Microsoft.CognitiveServices.Speech.Audio;

using Microsoft.CognitiveServices.Speech.Translation;

using System.Media;

namespace speech_translation

{

    class Program

    {

        private static SpeechConfig speechConfig;

        private static SpeechTranslationConfig translationConfig;

        static async Task Main(string[] args)

        {

            try

            {

                // Get config settings from AppSettings

                IConfigurationBuilder builder =                 new ConfigurationBuilder().AddJsonFile("appsettings.json");

                IConfigurationRoot configuration = builder.Build();

                string aiSvcKey = "1RBACOGNMJb"; //configuration["SpeechKey"];

                string aiSvcRegion = "eastus"; //configuration["SpeechRegion"];

                // Set console encoding to unicode

                Console.InputEncoding = Encoding.Unicode;

                Console.OutputEncoding = Encoding.Unicode;

                // Configure translation

                translationConfig = SpeechTranslationConfig.FromSubscription(aiSvcKey,                 aiSvcRegion);

                translationConfig.SpeechRecognitionLanguage = "en-US";

                translationConfig.AddTargetLanguage("fr");

                translationConfig.AddTargetLanguage("es");

                translationConfig.AddTargetLanguage("hi");

                Console.WriteLine("Ready to translate from " +                 translationConfig.SpeechRecognitionLanguage);

                // Configure speech

                speechConfig = SpeechConfig.FromSubscription(aiSvcKey, aiSvcRegion);

                string targetLanguage = "";

                while (targetLanguage != "quit")

                {

                    Console.WriteLine("\nEnter a target language\n fr = French\n es =                     Spanish\n hi = Hindi\n Enter anything else to stop\n");

                    targetLanguage = Console.ReadLine().ToLower();

                    if (translationConfig.TargetLanguages.Contains(targetLanguage))

                    {

                        await Translate(targetLanguage);

                    }

                    else

                    {

                        targetLanguage = "quit";

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message);

            }

        }

        static async Task Translate(string targetLanguage)

        {

            string translation = "";

            // Translate speech

            using AudioConfig audioConfig = AudioConfig.FromDefaultMicrophoneInput();

            using TranslationRecognizer translator = new TranslationRecognizer(translationConfig,             audioConfig);

            Console.WriteLine("Speak now...");

            TranslationRecognitionResult result = await translator.RecognizeOnceAsync();

            Console.WriteLine($"Translating '{result.Text}'");

            translation = result.Translations[targetLanguage];

            Console.OutputEncoding = Encoding.UTF8;

            Console.WriteLine(translation);

            // Translate speech

            // string audioFile = "station.wav";

            // SoundPlayer wavPlayer = new SoundPlayer(audioFile);

            // wavPlayer.Play();

            // using AudioConfig audioConfig = AudioConfig.FromWavFileInput(audioFile);

            // using TranslationRecognizer translator = new TranslationRecognizer(translationConfig,             audioConfig);

            // Console.WriteLine("Getting speech from file...");

            // TranslationRecognitionResult result = await translator.RecognizeOnceAsync();

            // Console.WriteLine($"Translating '{result.Text}'");

            // translation = result.Translations[targetLanguage];

            // Console.OutputEncoding = Encoding.UTF8;

            // Console.WriteLine(translation);

            // Synthesize translation

            var voices = new Dictionary<string, string>

            {

                ["fr"] = "fr-FR-HenriNeural",

                ["es"] = "es-ES-ElviraNeural",

                ["hi"] = "hi-IN-MadhurNeural"

            };

            speechConfig.SpeechSynthesisVoiceName = voices[targetLanguage];

            using SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer(speechConfig);

            SpeechSynthesisResult speak = await speechSynthesizer.SpeakTextAsync(translation);

            if (speak.Reason != ResultReason.SynthesizingAudioCompleted)

            {

                Console.WriteLine(speak.Reason);

            }

        }

    }

}

OutPut:

Python Code:

pip install azure-cognitiveservices-speech==1.30.0

pip install playsound==1.3.0

from dotenv import load_dotenv

from datetime import datetime

import os

# Import namespaces

import azure.cognitiveservices.speech as speech_sdk

def main():

    try:

        global speech_config

        global translation_config

        # Get Configuration Settings

        load_dotenv()

        ai_key = '1RBACOGNMJb' #os.getenv('SPEECH_KEY')

        ai_region = 'eastus' # os.getenv('SPEECH_REGION')

        # Configure translation

        translation_config = speech_sdk.translation.SpeechTranslationConfig(subscription=ai_key,         region=ai_region)

        translation_config.speech_recognition_language = 'en-US'

        translation_config.add_target_language('fr')

        translation_config.add_target_language('es')

        translation_config.add_target_language('hi')

        print('Ready to translate from', translation_config.speech_recognition_language)

        # Configure speech

        speech_config = speech_sdk.SpeechConfig(subscription=ai_key, region=ai_region)

        # Get user input

        targetLanguage = ''

        while targetLanguage != 'quit':

            targetLanguage = input('\nEnter a target language\n fr = French\n es = Spanish\n hi =             Hindi\n Enter anything else to stop\n').lower()

            if targetLanguage in translation_config.target_languages:

                Translate(targetLanguage)

            else:

                targetLanguage = 'quit'

               

    except Exception as ex:

        print(ex)

def Translate(targetLanguage):

    translation = ''

    # Translate speech

    audio_config = speech_sdk.AudioConfig(use_default_microphone=True)

    translator = speech_sdk.translation.TranslationRecognizer(translation_config=translation_config,     audio_config=audio_config)

    print("Speak now...")

    result = translator.recognize_once_async().get()

    if result.reason == speech_sdk.ResultReason.TranslatedSpeech:

        print('Translating "{}"'.format(result.text))

    for language, translation in result.translations.items():

        print('Translation in {}: {}'.format(language, translation))

    else:

        print("No speech could be recognized or translation failed.")

    # Synthesize translation

    voices = {

        "fr": "fr-FR-HenriNeural",

        "es": "es-ES-ElviraNeural",

        "hi": "hi-IN-MadhurNeural"

    }

 

    # Assuming `targetLanguage` and `translation` are defined

    targetLanguage = "fr"  # Replace this with the actual target language

    translation = "Bonjour tout le monde"  # Replace this with the actual translation

 

    # Set the speech synthesis voice name based on the target language

    speech_config.speech_synthesis_voice_name = voices.get(targetLanguage)

 

    # Initialize the speech synthesizer

    speech_synthesizer = speech_sdk.SpeechSynthesizer(speech_config)

 

    # Synthesize the translated text to speech

    speak = speech_synthesizer.speak_text_async(translation).get()

 

    # Check if the synthesis was successful

    if speak.reason != speech_sdk.ResultReason.SynthesizingAudioCompleted:

        print(speak.reason)

    else:

        print("Speech synthesis completed successfully.")

if __name__ == "__main__":

    main()

OutPut:

Python:

from dotenv import load_dotenv

from datetime import datetime

import os

# Import namespaces

import azure.cognitiveservices.speech as speech_sdk

def main():

    try:

        global speech_config

        global translation_config

        # Get Configuration Settings

        load_dotenv()

        ai_key = 'BI8xxusRRypyJeQHHhOe9ZblK3w3AAAYACOGawO8' # os.getenv('SPEECH_KEY')

        ai_region = 'eastus' # os.getenv('SPEECH_REGION')

        # Configure translation

        translation_config = speech_sdk.translation.SpeechTranslationConfig         (ai_key, ai_region)

        translation_config.speech_recognition_language = 'en-US'

        translation_config.add_target_language('fr')

        translation_config.add_target_language('es')

        translation_config.add_target_language('hi')

        print('Ready to translate from',         translation_config.speech_recognition_language)

        # Configure speech

        speech_config = speech_sdk.SpeechConfig(subscription=ai_key, region=ai_region)

        # Get user input

        targetLanguage = ''

        while targetLanguage != 'quit':

            targetLanguage = input('\nEnter a target language\n fr = French\n es =             Spanish\n hi = Hindi\n Enter anything else to stop\n').lower()

            if targetLanguage in translation_config.target_languages:

                Translate(targetLanguage)

            else:

                targetLanguage = 'quit'

    except Exception as ex:

        print(ex)

def Translate(targetLanguage):

    translation = ''

    # Translate speech

    audio_config = speech_sdk.AudioConfig(use_default_microphone=True)

    translator = speech_sdk.translation.TranslationRecognizer(translation_config,     audio_config=audio_config)

    print("Speak now...")

    result = translator.recognize_once_async().get()

    print('Translating "{}"'.format(result.text))

    translation = result.translations[targetLanguage]

    print(translation)

    # Synthesize translation

    voices = {

        "fr": "fr-FR-HenriNeural",

        "es": "es-ES-ElviraNeural",

        "hi": "hi-IN-MadhurNeural"

    }

    speech_config.speech_synthesis_voice_name = voices.get(targetLanguage)

    speech_synthesizer = speech_sdk.SpeechSynthesizer(speech_config)

    speak = speech_synthesizer.speak_text_async(translation).get()

    if speak.reason != speech_sdk.ResultReason.SynthesizingAudioCompleted:

        print(speak.reason)

if __name__ == "__main__":

    main()

Script: 
curl -X POST "https://sreemultiserviceaccount1.cognitiveservices.azure.com/language/:analyze-text?api-version=2023-04-01" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: 2D9XtWQ0YOGFMV1" --data-ascii "{'analysisInput':{'documents':[{'id':1,'text':'hola'}]}, 'kind': 'LanguageDetection'}"

OutPut: 

{"kind":"LanguageDetectionResults",

"results":{"documents":[{"id":"1","warnings":[],

"detectedLanguage":{"name":"Spanish","iso6391Name":"es","confidenceScore":1.0}}],"errors":[],"modelVersion":"2024-04-01"}}