azure.ai.formrecognizer.aio package

class azure.ai.formrecognizer.aio.FormRecognizerClient(endpoint: str, credential: Union[AzureKeyCredential, AsyncTokenCredential], **kwargs: Any)

FormRecognizerClient extracts information from forms and images into structured data. It is the interface to use for analyzing receipts, recognizing content/layout from forms, and analyzing custom forms from trained models. It provides different methods based on inputs from a URL and inputs from a stream.

Parameters

• endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).

• credential (AzureKeyCredential or AsyncTokenCredential) – Credentials needed for the client to connect to Azure. This is an instance of AzureKeyCredential if using an API key or a token credential from azure.identity.

Example:

Creating the FormRecognizerClient with an endpoint and API key.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormRecognizerClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

form_recognizer_client = FormRecognizerClient(endpoint, AzureKeyCredential(key))

Creating the FormRecognizerClient with a token credential.

"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
from azure.ai.formrecognizer.aio import FormRecognizerClient
from azure.identity.aio import DefaultAzureCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_AAD_ENDPOINT"]
credential = DefaultAzureCredential()

form_recognizer_client = FormRecognizerClient(endpoint, credential)

async begin_recognize_content(form: Union[bytes, IO[bytes]], **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[List[azure.ai.formrecognizer._models.FormPage]]

Extract text and content/layout information from a given document. The input document must be of one of the supported content types - ‘application/pdf’, ‘image/jpeg’, ‘image/png’ or ‘image/tiff’.

Parameters

form (bytes or IO[bytes]) – JPEG, PNG, PDF and TIFF type file stream or bytes.

Keyword Arguments

• content_type (str or FormContentType) – Media type of the body sent to the API. Content-type is auto-detected, but can be overridden by passing this keyword argument. For options, see FormContentType.

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a list[FormPage].

Return type

AsyncLROPoller[list[FormPage]]

Raises

HttpResponseError –

Example:

Recognize text and content/layout information from a form.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormRecognizerClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

async with FormRecognizerClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
) as form_recognizer_client:

    with open(path_to_sample_forms, "rb") as f:
        poller = await form_recognizer_client.begin_recognize_content(form=f)

    contents = await poller.result()

    for idx, content in enumerate(contents):
        print("----Recognizing content from page #{}----".format(idx))
        print("Has width: {} and height: {}, measured with unit: {}".format(
            content.width,
            content.height,
            content.unit
        ))
        for table_idx, table in enumerate(content.tables):
            print("Table # {} has {} rows and {} columns".format(table_idx, table.row_count, table.column_count))
            for cell in table.cells:
                print("...Cell[{}][{}] has text '{}' within bounding box '{}'".format(
                    cell.row_index,
                    cell.column_index,
                    cell.text,
                    format_bounding_box(cell.bounding_box)
                ))

async begin_recognize_content_from_url(form_url: str, **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[List[azure.ai.formrecognizer._models.FormPage]]

Extract text and layout information from a given document. The input document must be the location (URL) of the document to be analyzed.

Parameters

form_url (str) – The URL of the form to analyze. The input must be a valid, encoded URL of one of the supported formats: JPEG, PNG, PDF and TIFF.

Keyword Arguments

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a list[FormPage].

Return type

AsyncLROPoller[list[FormPage]]

Raises

HttpResponseError –

async begin_recognize_custom_forms(model_id: str, form: Union[bytes, IO[bytes]], **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[List[azure.ai.formrecognizer._models.RecognizedForm]]

Analyze a custom form with a model trained with or without labels. The form to analyze should be of the same type as the forms that were used to train the model. The input document must be of one of the supported content types - ‘application/pdf’, ‘image/jpeg’, ‘image/png’ or ‘image/tiff’.

Parameters

• model_id (str) – Custom model identifier.

• form (bytes or IO[bytes]) – JPEG, PNG, PDF and TIFF type file stream or bytes.

Keyword Arguments

• include_field_elements (bool) – Whether or not to include field elements such as lines and words in addition to form fields.

• content_type (str or FormContentType) – Media type of the body sent to the API. Content-type is auto-detected, but can be overridden by passing this keyword argument. For options, see FormContentType.

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a list[RecognizedForm].

Return type

AsyncLROPoller[list[RecognizedForm]

Raises

HttpResponseError –

Example:

Recognize fields and values from a custom form.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormRecognizerClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
model_id = os.environ["CUSTOM_TRAINED_MODEL_ID"]

async with FormRecognizerClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
) as form_recognizer_client:

    # Make sure your form's type is included in the list of form types the custom model can recognize
    with open(path_to_sample_forms, "rb") as f:
        poller = await form_recognizer_client.begin_recognize_custom_forms(
            model_id=model_id, form=f
        )
    forms = await poller.result()

    for idx, form in enumerate(forms):
        print("--------Recognizing Form #{}--------".format(idx))
        print("Form {} has type {}".format(idx, form.form_type))
        for name, field in form.fields.items():
            # each field is of type FormField
            # The value of the field can also be a FormField, or a list of FormFields
            # In our sample, it is just a FormField.
            print("...Field '{}' has value '{}' with a confidence score of {}".format(
                name, field.value, field.confidence
            ))
            # label data is populated if you are using a model trained with unlabeled data, since the service needs to make predictions for
            # labels if not explicitly given to it.
            if field.label_data:
                print("...Field '{}' has label '{}' with a confidence score of {}".format(
                    name,
                    field.label_data.text,
                    field.confidence
                ))
        print("-----------------------------------")

async begin_recognize_custom_forms_from_url(model_id: str, form_url: str, **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[List[azure.ai.formrecognizer._models.RecognizedForm]]

Analyze a custom form with a model trained with or without labels. The form to analyze should be of the same type as the forms that were used to train the model. The input document must be the location (URL) of the document to be analyzed.

Parameters

• model_id (str) – Custom model identifier.

• form_url (str) – The URL of the form to analyze. The input must be a valid, encoded URL of one of the supported formats: JPEG, PNG, PDF and TIFF.

Keyword Arguments

• include_field_elements (bool) – Whether or not to include field elements such as lines and words in addition to form fields.

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a list[RecognizedForm].

Return type

AsyncLROPoller[list[RecognizedForm]

Raises

HttpResponseError –

async begin_recognize_receipts(receipt: Union[bytes, IO[bytes]], **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[List[azure.ai.formrecognizer._models.RecognizedForm]]

Extract field text and semantic values from a given US sales receipt. The input document must be of one of the supported content types - ‘application/pdf’, ‘image/jpeg’, ‘image/png’ or ‘image/tiff’.

See fields found on a receipt here: https://aka.ms/azsdk/python/formrecognizer/receiptfields

Parameters

receipt (bytes or IO[bytes]) – JPEG, PNG, PDF and TIFF type file stream or bytes. Currently only supports US sales receipts.

Keyword Arguments

• include_field_elements (bool) – Whether or not to include field elements such as lines and words in addition to form fields.

• content_type (str or FormContentType) – Media type of the body sent to the API. Content-type is auto-detected, but can be overridden by passing this keyword argument. For options, see FormContentType.

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a list[RecognizedForm].

Return type

AsyncLROPoller[list[RecognizedForm]]

Raises

HttpResponseError –

Example:

Recognize US sales receipt fields.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormRecognizerClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

async with FormRecognizerClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
) as form_recognizer_client:

    with open(path_to_sample_forms, "rb") as f:
        poller = await form_recognizer_client.begin_recognize_receipts(receipt=f)

    receipts = await poller.result()

    for idx, receipt in enumerate(receipts):
        print("--------Recognizing receipt #{}--------".format(idx))
        receipt_type = receipt.fields.get("ReceiptType")
        if receipt_type:
            print("Receipt Type: {} has confidence: {}".format(receipt_type.value, receipt_type.confidence))
        merchant_name = receipt.fields.get("MerchantName")
        if merchant_name:
            print("Merchant Name: {} has confidence: {}".format(merchant_name.value, merchant_name.confidence))
        transaction_date = receipt.fields.get("TransactionDate")
        if transaction_date:
            print("Transaction Date: {} has confidence: {}".format(transaction_date.value, transaction_date.confidence))
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").value):
            print("...Item #{}".format(idx))
            item_name = item.value.get("Name")
            if item_name:
                print("......Item Name: {} has confidence: {}".format(item_name.value, item_name.confidence))
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print("......Item Quantity: {} has confidence: {}".format(item_quantity.value, item_quantity.confidence))
            item_price = item.value.get("Price")
            if item_price:
                print("......Individual Item Price: {} has confidence: {}".format(item_price.value, item_price.confidence))
            item_total_price = item.value.get("TotalPrice")
            if item_total_price:
                print("......Total Item Price: {} has confidence: {}".format(item_total_price.value, item_total_price.confidence))
        subtotal = receipt.fields.get("Subtotal")
        if subtotal:
            print("Subtotal: {} has confidence: {}".format(subtotal.value, subtotal.confidence))
        tax = receipt.fields.get("Tax")
        if tax:
            print("Tax: {} has confidence: {}".format(tax.value, tax.confidence))
        tip = receipt.fields.get("Tip")
        if tip:
            print("Tip: {} has confidence: {}".format(tip.value, tip.confidence))
        total = receipt.fields.get("Total")
        if total:
            print("Total: {} has confidence: {}".format(total.value, total.confidence))
        print("--------------------------------------")

async begin_recognize_receipts_from_url(receipt_url: str, **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[List[azure.ai.formrecognizer._models.RecognizedForm]]

Extract field text and semantic values from a given US sales receipt. The input document must be the location (URL) of the receipt to be analyzed.

See fields found on a receipt here: https://aka.ms/azsdk/python/formrecognizer/receiptfields

Parameters

receipt_url (str) – The URL of the receipt to analyze. The input must be a valid, encoded URL of one of the supported formats: JPEG, PNG, PDF and TIFF. Currently only supports US sales receipts.

Keyword Arguments

• include_field_elements (bool) – Whether or not to include field elements such as lines and words in addition to form fields.

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a list[RecognizedForm].

Return type

AsyncLROPoller[list[RecognizedForm]]

Raises

HttpResponseError –

Example:

Recognize US sales receipt fields from a URL.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormRecognizerClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

async with FormRecognizerClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
) as form_recognizer_client:
    url = "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/master/sdk/formrecognizer/azure-ai-formrecognizer/tests/sample_forms/receipt/contoso-receipt.png"
    poller = await form_recognizer_client.begin_recognize_receipts_from_url(receipt_url=url)
    receipts = await poller.result()

    for idx, receipt in enumerate(receipts):
        print("--------Recognizing receipt #{}--------".format(idx))
        receipt_type = receipt.fields.get("ReceiptType")
        if receipt_type:
            print("Receipt Type: {} has confidence: {}".format(receipt_type.value, receipt_type.confidence))
        merchant_name = receipt.fields.get("MerchantName")
        if merchant_name:
            print("Merchant Name: {} has confidence: {}".format(merchant_name.value, merchant_name.confidence))
        transaction_date = receipt.fields.get("TransactionDate")
        if transaction_date:
            print("Transaction Date: {} has confidence: {}".format(transaction_date.value, transaction_date.confidence))
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").value):
            print("...Item #{}".format(idx))
            item_name = item.value.get("Name")
            if item_name:
                print("......Item Name: {} has confidence: {}".format(item_name.value, item_name.confidence))
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print("......Item Quantity: {} has confidence: {}".format(item_quantity.value, item_quantity.confidence))
            item_price = item.value.get("Price")
            if item_price:
                print("......Individual Item Price: {} has confidence: {}".format(item_price.value, item_price.confidence))
            item_total_price = item.value.get("TotalPrice")
            if item_total_price:
                print("......Total Item Price: {} has confidence: {}".format(item_total_price.value, item_total_price.confidence))
        subtotal = receipt.fields.get("Subtotal")
        if subtotal:
            print("Subtotal: {} has confidence: {}".format(subtotal.value, subtotal.confidence))
        tax = receipt.fields.get("Tax")
        if tax:
            print("Tax: {} has confidence: {}".format(tax.value, tax.confidence))
        tip = receipt.fields.get("Tip")
        if tip:
            print("Tip: {} has confidence: {}".format(tip.value, tip.confidence))
        total = receipt.fields.get("Total")
        if total:
            print("Total: {} has confidence: {}".format(total.value, total.confidence))
        print("--------------------------------------")

async close() → None

Close the FormRecognizerClient session.

class azure.ai.formrecognizer.aio.FormTrainingClient(endpoint: str, credential: Union[AzureKeyCredential, AsyncTokenCredential], **kwargs: Any)

FormTrainingClient is the Form Recognizer interface to use for creating, and managing custom models. It provides methods for training models on the forms you provide, as well as methods for viewing and deleting models, accessing account properties, and copying a model to another Form Recognizer resource.

Parameters

• endpoint (str) – Supported Cognitive Services endpoints (protocol and hostname, for example: https://westus2.api.cognitive.microsoft.com).

• credential (AzureKeyCredential or AsyncTokenCredential) – Credentials needed for the client to connect to Azure. This is an instance of AzureKeyCredential if using an API key or a token credential from azure.identity.

Example:

Creating the FormTrainingClient with an endpoint and API key.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormTrainingClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

form_training_client = FormTrainingClient(endpoint, AzureKeyCredential(key))

Creating the FormTrainingClient with a token credential.

"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.identity.aio import DefaultAzureCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_AAD_ENDPOINT"]
credential = DefaultAzureCredential()

form_training_client = FormTrainingClient(endpoint, credential)

async begin_copy_model(model_id: str, target: dict, **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[azure.ai.formrecognizer._models.CustomFormModelInfo]

Copy a custom model stored in this resource (the source) to the user specified target Form Recognizer resource. This should be called with the source Form Recognizer resource (with the model that is intended to be copied). The target parameter should be supplied from the target resource’s output from calling the get_copy_authorization() method.

Parameters

• model_id (str) – Model identifier of the model to copy to target resource.

• target (dict) – The copy authorization generated from the target resource’s call to get_copy_authorization().

Keyword Arguments

• polling_interval (int) – Default waiting time between two polls for LRO operations if no Retry-After header is present.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a CustomFormModelInfo.

Return type

AsyncLROPoller[CustomFormModelInfo]

Raises

HttpResponseError –

Example:

Copy a model from the source resource to the target resource

source_client = FormTrainingClient(endpoint=source_endpoint, credential=AzureKeyCredential(source_key))

async with source_client:
    poller = await source_client.begin_copy_model(
        model_id=source_model_id,
        target=target  # output from target client's call to get_copy_authorization()
    )
    copied_over_model = await poller.result()

    print("Model ID: {}".format(copied_over_model.model_id))
    print("Status: {}".format(copied_over_model.status))

async begin_training(training_files_url: str, use_training_labels: bool, **kwargs: Any) → azure.core.polling._async_poller.AsyncLROPoller[azure.ai.formrecognizer._models.CustomFormModel]

Create and train a custom model. The request must include a training_files_url parameter that is an externally accessible Azure storage blob container URI (preferably a Shared Access Signature URI). Note that a container URI is accepted only when the container is public. Models are trained using documents that are of the following content type - ‘application/pdf’, ‘image/jpeg’, ‘image/png’, ‘image/tiff’. Other type of content in the container is ignored.

Parameters

• training_files_url (str) – An Azure Storage blob container’s SAS URI. A container URI can be used if the container is public.

• use_training_labels (bool) – Whether to train with labels or not. Corresponding labeled files must exist in the blob container.

Keyword Arguments

• prefix (str) – A case-sensitive prefix string to filter documents in the source path for training. For example, when using a Azure storage blob URI, use the prefix to restrict sub folders for training.

• include_sub_folders (bool) – A flag to indicate if sub folders within the set of prefix folders will also need to be included when searching for content to be preprocessed. Not supported if training with labels.

• polling_interval (int) – Waiting time between two polls for LRO operations if no Retry-After header is present. Defaults to 5 seconds.

• continuation_token (str) – A continuation token to restart a poller from a saved state.

Returns

An instance of an AsyncLROPoller. Call result() on the poller object to return a CustomFormModel.

Return type

AsyncLROPoller[CustomFormModel]

Raises

HttpResponseError – Note that if the training fails, the exception is raised, but a model with an “invalid” status is still created. You can delete this model by calling delete_model()

Example:

Training a model with your custom forms.

from azure.ai.formrecognizer.aio import FormTrainingClient
from azure.core.credentials import AzureKeyCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]

async with FormTrainingClient(
    endpoint, AzureKeyCredential(key)
) as form_training_client:

    poller = await form_training_client.begin_training(container_sas_url, use_training_labels=False)
    model = await poller.result()

    # Custom model information
    print("Model ID: {}".format(model.model_id))
    print("Status: {}".format(model.status))
    print("Training started on: {}".format(model.training_started_on))
    print("Training completed on: {}".format(model.training_completed_on))

    print("Recognized fields:")
    # Looping through the submodels, which contains the fields they were trained on
    for submodel in model.submodels:
        print("...The submodel has form type '{}'".format(submodel.form_type))
        for name, field in submodel.fields.items():
            print("...The model found field '{}' to have label '{}'".format(
                name, field.label
            ))

async close() → None

Close the FormTrainingClient session.

async delete_model(model_id: str, **kwargs: Any) → None

Mark model for deletion. Model artifacts will be permanently removed within a predetermined period.

Parameters

model_id (str) – Model identifier.

Return type

None

Raises

HttpResponseError or ResourceNotFoundError –

Example:

Delete a custom model.

await form_training_client.delete_model(model_id=custom_model.model_id)

try:
    await form_training_client.get_custom_model(model_id=custom_model.model_id)
except ResourceNotFoundError:
    print("Successfully deleted model with id {}".format(custom_model.model_id))

async get_account_properties(**kwargs: Any) → azure.ai.formrecognizer._models.AccountProperties

Get information about the models on the form recognizer account.

Returns

Summary of models on account - custom model count, custom model limit.

Return type

AccountProperties

Raises

HttpResponseError –

Example:

Get properties for the form recognizer account.

from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.formrecognizer.aio import FormTrainingClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

async with FormTrainingClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
) as form_training_client:
    # First, we see how many custom models we have, and what our limit is
    account_properties = await form_training_client.get_account_properties()
    print("Our account has {} custom models, and we can have at most {} custom models".format(
        account_properties.custom_model_count, account_properties.custom_model_limit
    ))

async get_copy_authorization(resource_id: str, resource_region: str, **kwargs: Any) → Dict[str, Union[str, int]]

Generate authorization for copying a custom model into the target Form Recognizer resource. This should be called by the target resource (where the model will be copied to) and the output can be passed as the target parameter into begin_copy_model().

Parameters

• resource_id (str) – Azure Resource Id of the target Form Recognizer resource where the model will be copied to.

• resource_region (str) – Location of the target Form Recognizer resource. A valid Azure region name supported by Cognitive Services. For example, ‘westus’, ‘eastus’ etc. See https://azure.microsoft.com/global-infrastructure/services/?products=cognitive-services for the regional availability of Cognitive Services

Returns

A dictionary with values for the copy authorization - “modelId”, “accessToken”, “resourceId”, “resourceRegion”, and “expirationDateTimeTicks”.

Return type

Dict[str, Union[str, int]]

Raises

HttpResponseError –

Example:

Authorize the target resource to receive the copied model

target_client = FormTrainingClient(endpoint=target_endpoint, credential=AzureKeyCredential(target_key))

async with target_client:
    target = await target_client.get_copy_authorization(
        resource_region=target_region,
        resource_id=target_resource_id
    )
# model ID that target client will use to access the model once copy is complete
print("Model ID: {}".format(target["modelId"]))

async get_custom_model(model_id: str, **kwargs: Any) → azure.ai.formrecognizer._models.CustomFormModel

Get a description of a custom model, including the types of forms it can recognize, and the fields it will extract for each form type.

Parameters

model_id (str) – Model identifier.

Returns

CustomFormModel

Return type

CustomFormModel

Raises

HttpResponseError or ResourceNotFoundError –

Example:

Get a custom model with a model ID.

custom_model = await form_training_client.get_custom_model(model_id=first_model.model_id)
print("Model ID: {}".format(custom_model.model_id))
print("Status: {}".format(custom_model.status))
print("Training started on: {}".format(custom_model.training_started_on))
print("Training completed on: {}".format(custom_model.training_completed_on))

get_form_recognizer_client(**kwargs: Any) → azure.ai.formrecognizer.aio._form_recognizer_client_async.FormRecognizerClient

Get an instance of a FormRecognizerClient from FormTrainingClient.

Return type

FormRecognizerClient

Returns

A FormRecognizerClient

list_custom_models(**kwargs: Any) → azure.core.async_paging.AsyncItemPaged[azure.ai.formrecognizer._models.CustomFormModelInfo]

List information for each model, including model id, model status, and when it was created and last modified.

Returns

AsyncItemPaged[CustomFormModelInfo]

Return type

AsyncItemPaged

Raises

HttpResponseError –

Example:

List model information for each model on the account.

custom_models = form_training_client.list_custom_models()

print("We have models with the following ids:")

# Let's pull out the first model
first_model = None
async for model in custom_models:
    print(model.model_id)
    if not first_model:
        first_model = model