Exemple #1
0
async def sample_translation_with_glossaries_async():
    import os
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.translation.document.aio import DocumentTranslationClient
    from azure.ai.translation.document import (DocumentTranslationInput,
                                               TranslationTarget,
                                               TranslationGlossary)

    endpoint = os.environ["AZURE_DOCUMENT_TRANSLATION_ENDPOINT"]
    key = os.environ["AZURE_DOCUMENT_TRANSLATION_KEY"]
    source_container_url = os.environ["AZURE_SOURCE_CONTAINER_URL"]
    target_container_url = os.environ["AZURE_TARGET_CONTAINER_URL"]
    glossary_url = os.environ["AZURE_TRANSLATION_GLOSSARY_URL"]

    client = DocumentTranslationClient(endpoint, AzureKeyCredential(key))

    inputs = DocumentTranslationInput(
        source_url=source_container_url,
        targets=[
            TranslationTarget(target_url=target_container_url,
                              language_code="es",
                              glossaries=[
                                  TranslationGlossary(
                                      glossary_url=glossary_url,
                                      file_format="TSV")
                              ])
        ])

    async with client:
        job = await client.create_translation_job(inputs=[inputs]
                                                  )  # type: JobStatusResult

        job_result = await client.wait_until_done(job.id
                                                  )  # type: JobStatusResult

        print("Job status: {}".format(job_result.status))
        print("Job created on: {}".format(job_result.created_on))
        print("Job last updated on: {}".format(job_result.last_updated_on))
        print("Total number of translations on documents: {}".format(
            job_result.documents_total_count))

        print("\nOf total documents...")
        print("{} failed".format(job_result.documents_failed_count))
        print("{} succeeded".format(job_result.documents_succeeded_count))

        doc_results = client.list_all_document_statuses(
            job_result.id)  # type: AsyncItemPaged[DocumentStatusResult]
        async for document in doc_results:
            print("Document ID: {}".format(document.id))
            print("Document status: {}".format(document.status))
            if document.status == "Succeeded":
                print("Source document location: {}".format(
                    document.source_document_url))
                print("Translated document location: {}".format(
                    document.translated_document_url))
                print("Translated to language: {}\n".format(
                    document.translate_to))
            else:
                print("Error Code: {}, Message: {}\n".format(
                    document.error.code, document.error.message))
Exemple #2
0
async def sample_document_status_checks_async():
    import os
    # [START create_translation_job_async]
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.translation.document.aio import DocumentTranslationClient
    from azure.ai.translation.document import (DocumentTranslationInput,
                                               TranslationTarget)

    endpoint = os.environ["AZURE_DOCUMENT_TRANSLATION_ENDPOINT"]
    key = os.environ["AZURE_DOCUMENT_TRANSLATION_KEY"]
    source_container_url = os.environ["AZURE_SOURCE_CONTAINER_URL"]
    target_container_url = os.environ["AZURE_TARGET_CONTAINER_URL"]

    client = DocumentTranslationClient(endpoint, AzureKeyCredential(key))
    async with client:
        job_result = await client.create_translation_job(
            inputs=[
                DocumentTranslationInput(
                    source_url=source_container_url,
                    targets=[
                        TranslationTarget(target_url=target_container_url,
                                          language_code="es")
                    ])
            ])  # type: JobStatusResult
        # [END create_translation_job_async]

        completed_docs = []
        while not job_result.has_completed:
            await asyncio.sleep(30)

            doc_statuses = client.list_all_document_statuses(job_result.id)
            async for document in doc_statuses:
                if document.id not in completed_docs:
                    if document.status == "Succeeded":
                        print(
                            "Document at {} was translated to {} language. You can find translated document at {}"
                            .format(document.source_document_url,
                                    document.translate_to,
                                    document.translated_document_url))
                        completed_docs.append(document.id)
                    if document.status == "Failed":
                        print("Document ID: {}, Error Code: {}, Message: {}".
                              format(document.id, document.error.code,
                                     document.error.message))
                        completed_docs.append(document.id)
                    if document.status == "Running":
                        print(
                            "Document ID: {}, translation progress is {} percent"
                            .format(document.id,
                                    document.translation_progress * 100))

            job_result = await client.get_job_status(job_result.id)

        print("\nTranslation job completed.")
async def sample_list_document_statuses_with_filters_async():
    # import libraries
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.translation.document.aio import (
        DocumentTranslationClient,
    )
    from datetime import datetime

    # obtain client secrets
    endpoint = os.environ["AZURE_DOCUMENT_TRANSLATION_ENDPOINT"]
    key = os.environ["AZURE_DOCUMENT_TRANSLATION_KEY"]
    translation_id = os.environ["TRANSLATION_ID"]  # this should be the id for the translation operation you'd like to list docs for!

    # authorize client
    client = DocumentTranslationClient(endpoint, AzureKeyCredential(key))

    # set your filters
    '''
        Note:
            these are just sample values for the filters!
            please comment/uncomment/change what you are interested in using.
    '''
    start = datetime(2021, 4, 12)
    end = datetime(2021, 4, 14)
    statuses = ["Cancelled", "Failed"]
    order_by = ["createdDateTimeUtc desc"]
    results_per_page = 2
    skip = 3

    async with client:
        filtered_docs = client.list_all_document_statuses(
            translation_id,
            # filters
            statuses=statuses,
            translated_after=start,
            translated_before=end,
            # ordering
            order_by=order_by,
            # paging
            skip=skip,
            results_per_page=results_per_page
        ).by_page()

        # check statuses
        async for page in filtered_docs:
            async for doc in page:
                display_doc_info(doc)
async def sample_document_status_checks_async():
    # [START list_all_document_statuses_async]
    import os
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.translation.document.aio import DocumentTranslationClient

    endpoint = os.environ["AZURE_DOCUMENT_TRANSLATION_ENDPOINT"]
    key = os.environ["AZURE_DOCUMENT_TRANSLATION_KEY"]
    source_container_url = os.environ["AZURE_SOURCE_CONTAINER_URL"]
    target_container_url = os.environ["AZURE_TARGET_CONTAINER_URL"]

    client = DocumentTranslationClient(endpoint, AzureKeyCredential(key))

    async with client:
        poller = await client.begin_translation(source_container_url,
                                                target_container_url, "es")

        completed_docs = []
        while poller.status() in ["Running", "NotStarted"]:
            await asyncio.sleep(30)

            doc_statuses = client.list_all_document_statuses(poller.id)
            async for document in doc_statuses:
                if document.id not in completed_docs:
                    if document.status == "Succeeded":
                        print(
                            "Document at {} was translated to {} language. You can find translated document at {}"
                            .format(document.source_document_url,
                                    document.translated_to,
                                    document.translated_document_url))
                        completed_docs.append(document.id)
                    if document.status == "Failed":
                        print(
                            "Document at {} failed translation. Error Code: {}, Message: {}"
                            .format(document.source_document_url,
                                    document.error.code,
                                    document.error.message))
                        completed_docs.append(document.id)
                    if document.status == "Running":
                        print(
                            "Document ID: {}, translation progress is {} percent"
                            .format(document.id,
                                    document.translation_progress * 100))

        print("\nTranslation completed.")
Exemple #5
0
    async def sample_translation_with_azure_blob(self):

        translation_client = DocumentTranslationClient(
            self.endpoint, AzureKeyCredential(self.key))

        blob_service_client = BlobServiceClient(self.storage_endpoint,
                                                credential=self.storage_key)

        source_container = await self.create_container(
            blob_service_client,
            container_name=self.storage_source_container_name
            or "translation-source-container",
        )
        target_container = await self.create_container(
            blob_service_client,
            container_name=self.storage_target_container_name
            or "translation-target-container")

        if self.document_name:
            with open(self.document_name, "rb") as doc:
                await source_container.upload_blob(self.document_name, doc)
        else:
            self.document_name = "example_document.txt"
            await source_container.upload_blob(
                name=self.document_name,
                data=
                b"This is an example translation with the document translation client library"
            )
        print("Uploaded document {} to storage container {}".format(
            self.document_name, source_container.container_name))

        source_container_sas_url = self.generate_sas_url(source_container,
                                                         permissions="rl")
        target_container_sas_url = self.generate_sas_url(target_container,
                                                         permissions="wl")

        translation_inputs = [
            DocumentTranslationInput(
                source_url=source_container_sas_url,
                targets=[
                    TranslationTarget(target_url=target_container_sas_url,
                                      language_code="fr")
                ])
        ]

        job = await translation_client.create_translation_job(
            translation_inputs)
        print("Created translation job with ID: {}".format(job.id))
        print("Waiting until job completes...")

        job_result = await translation_client.wait_until_done(job.id)
        print("Job status: {}".format(job_result.status))

        doc_results = translation_client.list_all_document_statuses(
            job_result.id)

        print("\nDocument results:")
        async for document in doc_results:
            print("Document ID: {}".format(document.id))
            print("Document status: {}".format(document.status))
            if document.status == "Succeeded":
                print("Source document location: {}".format(
                    document.source_document_url))
                print("Translated document location: {}".format(
                    document.translated_document_url))
                print("Translated to language: {}\n".format(
                    document.translate_to))

                blob_client = BlobClient.from_blob_url(
                    document.translated_document_url,
                    credential=self.storage_key)
                async with blob_client:
                    with open("translated_" + self.document_name,
                              "wb") as my_blob:
                        download_stream = await blob_client.download_blob()
                        my_blob.write(await download_stream.readall())

                print("Downloaded {} locally".format("translated_" +
                                                     self.document_name))
            else:
                print("\nThere was a problem translating your document.")
                print("Document Error Code: {}, Message: {}\n".format(
                    document.error.code, document.error.message))

        await translation_client.close()
        await blob_service_client.close()