def test_custom_form_bad_endpoint(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
with open(self.form_jpg, "rb") as fd:
myfile = fd.read()
with self.assertRaises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(form_recognizer_account_key))
poller = client.begin_recognize_custom_forms(model_id="xx",
form=myfile)
def test_receipt_stream_transform_jpg(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
client = FormRecognizerClient(form_recognizer_account, AzureKeyCredential(form_recognizer_account_key))
responses = []
def callback(raw_response, _, headers):
analyze_result = client._client._deserialize(AnalyzeOperationResult, raw_response)
extracted_receipt = prepare_receipt(analyze_result)
responses.append(analyze_result)
responses.append(extracted_receipt)
with open(self.receipt_jpg, "rb") as fd:
myfile = fd.read()
poller = client.begin_recognize_receipts(
receipt=myfile,
include_text_content=True,
cls=callback
)
result = poller.result()
raw_response = responses[0]
returned_model = responses[1]
receipt = returned_model[0]
actual = raw_response.analyze_result.document_results[0].fields
read_results = raw_response.analyze_result.read_results
document_results = raw_response.analyze_result.document_results
page_results = raw_response.analyze_result.page_results
# check dict values
self.assertFormFieldTransformCorrect(receipt.fields.get("MerchantAddress"), actual.get("MerchantAddress"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("MerchantName"), actual.get("MerchantName"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("MerchantPhoneNumber"), actual.get("MerchantPhoneNumber"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Subtotal"), actual.get("Subtotal"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Tax"), actual.get("Tax"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Tip"), actual.get("Tip"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Total"), actual.get("Total"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("TransactionDate"), actual.get("TransactionDate"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("TransactionTime"), actual.get("TransactionTime"), read_results)
# check page range
self.assertEqual(receipt.page_range.first_page_number, document_results[0].page_range[0])
self.assertEqual(receipt.page_range.last_page_number, document_results[0].page_range[1])
# check receipt type
receipt_type = receipt.fields.get("ReceiptType")
self.assertEqual(receipt_type.confidence, actual["ReceiptType"].confidence)
self.assertEqual(receipt_type.value, actual["ReceiptType"].value_string)
# check receipt items
self.assertReceiptItemsTransformCorrect(receipt.fields["Items"].value, actual["Items"], read_results)
# Check form pages
self.assertFormPagesTransformCorrect(receipt.pages, read_results)
def test_passing_unsupported_url_content_type(self, resource_group,
location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with self.assertRaises(TypeError):
poller = client.begin_recognize_receipts(
"https://badurl.jpg", content_type="application/json")
def test_damaged_file_passed_as_bytes_io(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
damaged_pdf = BytesIO(
b"\x25\x50\x44\x46\x55\x55\x55"
) # still has correct bytes to be recognized as PDF
with self.assertRaises(HttpResponseError):
poller = client.begin_recognize_receipts(damaged_pdf, )
def test_passing_bad_content_type_param_passed(
self, resource_group, location, form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with open(self.receipt_jpg, "rb") as fd:
myfile = fd.read()
with self.assertRaises(ValueError):
poller = client.begin_recognize_receipts(
myfile, content_type="application/jpeg")
def recognize_receipts_from_url(self):
# [START recognize_receipts_from_url]
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import FormRecognizerClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
form_recognizer_client = FormRecognizerClient(
endpoint=endpoint, credential=AzureKeyCredential(key)
)
url = "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/master/sdk/formrecognizer/azure-ai-formrecognizer/tests/sample_forms/receipt/contoso-receipt.png"
poller = form_recognizer_client.begin_recognize_receipts_from_url(receipt_url=url)
receipts = poller.result()
for idx, receipt in enumerate(receipts):
print("--------Recognizing receipt #{}--------".format(idx+1))
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+1))
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("--------------------------------------")
def test_blank_page(self, resource_group, location,
form_recognizer_account, form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with open(self.blank_pdf, "rb") as fd:
blank = fd.read()
poller = client.begin_recognize_receipts(blank, )
result = poller.result()
self.assertIsNotNone(result)
def convert_to_and_from_dict():
path_to_sample_forms = os.path.abspath(
os.path.join(
os.path.abspath(__file__),
"..",
"..",
"./sample_forms/id_documents/license.jpg",
))
from azure.core.serialization import AzureJSONEncoder
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import FormRecognizerClient, RecognizedForm
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
form_recognizer_client = FormRecognizerClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
with open(path_to_sample_forms, "rb") as f:
poller = form_recognizer_client.begin_recognize_identity_documents(
identity_document=f)
id_documents = poller.result()
# convert the received model to a dictionary
recognized_form_dict = [doc.to_dict() for doc in id_documents]
# save the dictionary as JSON content in a JSON file, use the AzureJSONEncoder
# to help make types, such as dates, JSON serializable
# NOTE: AzureJSONEncoder is only available with azure.core>=1.18.0.
with open('data.json', 'w') as f:
json.dump(recognized_form_dict, f, cls=AzureJSONEncoder)
# convert the dictionary back to the original model
model = [RecognizedForm.from_dict(doc) for doc in recognized_form_dict]
# use the model as normal
for idx, id_document in enumerate(model):
print("--------Recognizing converted ID document #{}--------".format(
idx + 1))
first_name = id_document.fields.get("FirstName")
if first_name:
print("First Name: {} has confidence: {}".format(
first_name.value, first_name.confidence))
last_name = id_document.fields.get("LastName")
if last_name:
print("Last Name: {} has confidence: {}".format(
last_name.value, last_name.confidence))
document_number = id_document.fields.get("DocumentNumber")
if document_number:
print("Document Number: {} has confidence: {}".format(
document_number.value, document_number.confidence))
print("----------------------------------------")
def test_passing_unsupported_url_content_type(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
with self.assertRaises(TypeError):
poller = client.begin_recognize_custom_forms(
model_id="xx",
form="https://badurl.jpg",
content_type="application/json")
def test_pass_stream_into_url(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
with open(self.unsupported_content_py, "rb") as fd:
with self.assertRaises(HttpResponseError):
poller = client.begin_recognize_custom_forms_from_url(
model_id="xxx",
form_url=fd,
)
def test_receipt_continuation_token(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
client = FormRecognizerClient(form_recognizer_account, AzureKeyCredential(form_recognizer_account_key))
with open(self.receipt_jpg, "rb") as fd:
receipt = fd.read()
initial_poller = client.begin_recognize_receipts(receipt)
cont_token = initial_poller.continuation_token()
poller = client.begin_recognize_receipts(receipt, continuation_token=cont_token)
result = poller.result()
self.assertIsNotNone(result)
initial_poller.wait() # necessary so azure-devtools doesn't throw assertion error
def test_passing_enum_content_type(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with open(self.invoice_pdf, "rb") as fd:
myfile = fd.read()
poller = client.begin_recognize_content(
myfile, content_type=FormContentType.application_pdf)
result = poller.result()
self.assertIsNotNone(result)
def test_content_url_pdf(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
client = FormRecognizerClient(form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
poller = client.begin_recognize_content_from_url(self.invoice_url_pdf)
result = poller.result()
self.assertEqual(len(result), 1)
layout = result[0]
self.assertEqual(layout.page_number, 1)
self.assertFormPagesHasValues(result)
self.assertEqual(layout.tables[0].row_count, 2)
self.assertEqual(layout.tables[0].column_count, 6)
def test_custom_forms_encoded_url(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
try:
poller = client.begin_recognize_custom_forms_from_url(
model_id="00000000-0000-0000-0000-000000000000",
form_url="https://fakeuri.com/blank%20space")
except HttpResponseError as e:
self.assertIn("https://fakeuri.com/blank%20space",
e.response.request.body)
def test_content_multipage_url(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
poller = client.begin_recognize_content_from_url(
self.multipage_url_pdf)
result = poller.result()
self.assertEqual(len(result), 3)
self.assertFormPagesHasValues(result)
def recognize_content(self):
path_to_sample_forms = os.path.abspath(
os.path.join(os.path.abspath(__file__), "..",
"./sample_forms/forms/form_selection_mark.png"))
# [START recognize_content]
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import FormRecognizerClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
form_recognizer_client = FormRecognizerClient(
endpoint=endpoint, credential=AzureKeyCredential(key))
with open(path_to_sample_forms, "rb") as f:
poller = form_recognizer_client.begin_recognize_content(form=f)
form_pages = poller.result()
for idx, content in enumerate(form_pages):
print("----Recognizing content from page #{}----".format(idx + 1))
print("Page 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))
print("Table # {} location on page: {}".format(
table_idx, format_bounding_box(table.bounding_box)))
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)))
for line_idx, line in enumerate(content.lines):
print(
"Line # {} has word count '{}' and text '{}' within bounding box '{}'"
.format(line_idx, len(line.words), line.text,
format_bounding_box(line.bounding_box)))
if line.appearance:
if line.appearance.style_name == "handwriting" and line.appearance.style_confidence > 0.8:
print(
"Text line '{}' is handwritten and might be a signature."
.format(line.text))
for word in line.words:
print("...Word '{}' has a confidence of {}".format(
word.text, word.confidence))
for selection_mark in content.selection_marks:
print(
"Selection mark is '{}' within bounding box '{}' and has a confidence of {}"
.format(selection_mark.state,
format_bounding_box(selection_mark.bounding_box),
selection_mark.confidence))
print("----------------------------------------")
def recognize_custom_forms(self):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import FormRecognizerClient
form_recognizer_client = FormRecognizerClient(
endpoint=self.endpoint, credential=AzureKeyCredential(self.key)
)
# Make sure your form's type is included in the list of form types the custom model can recognize
with open("sample_forms/forms/Form_1.jpg", "rb") as f:
stream = f.read()
forms_with_labeled_model_poller = form_recognizer_client.begin_recognize_custom_forms(
model_id=self.model_trained_with_labels_id, stream=stream
)
forms_with_unlabeled_model_poller = form_recognizer_client.begin_recognize_custom_forms(
model_id=self.model_trained_without_labels_id, stream=stream
)
# Calling result after kicking off each call allows for server-side paralellization
forms_with_labeled_model = forms_with_labeled_model_poller.result()
forms_with_unlabeled_model = forms_with_unlabeled_model_poller.result()
# With a form recognized by a model trained with labels, this 'name' key will be its
# training-time label, otherwise it will be denoted by numeric indices.
# Label data is not returned for model trained with labels.
print("---------Recognizing forms with models trained with labeled data---------")
for labeled_form in forms_with_labeled_model:
for name, field in labeled_form.fields.items():
print("...Field '{}' has value '{}' based on '{}' within bounding box '{}', with a confidence score of {}".format(
name,
field.value,
field.value_data.text,
format_bounding_box(field.value_data.bounding_box),
field.confidence
))
print("-----------------------------------------------------------------------")
print("-------Recognizing forms with models trained with unlabeled data-------")
for unlabeled_form in forms_with_unlabeled_model:
for name, field in unlabeled_form.fields.items():
print("...Field '{}' has label '{}' within bounding box '{}', with a confidence score of {}".format(
name,
field.label_data.text,
format_bounding_box(field.label_data.bounding_box),
field.confidence
))
print("...Field '{}' has value '{}' based on '{}' within bounding box '{}', with a confidence score of {}".format(
name,
field.value,
field.value_data.text,
format_bounding_box(field.value_data.bounding_box),
field.confidence
))
def test_auto_detect_unsupported_stream_content(
self, resource_group, location, form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with open(self.unsupported_content_py, "rb") as fd:
myfile = fd.read()
with self.assertRaises(ValueError):
poller = client.begin_recognize_content(myfile)
def test_content_multipage(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with open(self.multipage_invoice_pdf, "rb") as fd:
invoice = fd.read()
poller = client.begin_recognize_content(invoice)
result = poller.result()
self.assertEqual(len(result), 3)
self.assertFormPagesHasValues(result)
def test_auto_detect_unsupported_stream_content(
self, formrecognizer_test_endpoint, formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
with open(self.unsupported_content_py, "rb") as fd:
myfile = fd.read()
with self.assertRaises(ValueError):
poller = client.begin_recognize_custom_forms(
model_id="xxx",
form=myfile,
)
def authentication_with_api_key_credential_form_recognizer_client(self):
# [START create_fr_client_with_key]
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import FormRecognizerClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
form_recognizer_client = FormRecognizerClient(endpoint,
AzureKeyCredential(key))
# [END create_fr_client_with_key]
poller = form_recognizer_client.begin_recognize_content_from_url(
self.url)
result = poller.result()
def test_receipt(self, resource_group, location, form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
response = client.begin_extract_receipts_from_url(
url=
"https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/contoso-allinone.jpg",
include_text_details=True)
result = response.result()
self.assertIsNotNone(result)
def test_get_form_training_client(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
transport = RequestsTransport()
frc = FormRecognizerClient(endpoint=form_recognizer_account, credential=AzureKeyCredential(form_recognizer_account_key), transport=transport)
with frc:
poller = frc.begin_recognize_receipts_from_url(self.receipt_url_jpg)
result = poller.result()
assert transport.session is not None
with frc.get_form_training_client() as ftc:
assert transport.session is not None
properties = ftc.get_account_properties()
poller = frc.begin_recognize_receipts_from_url(self.receipt_url_jpg)
result = poller.result()
assert transport.session is not None
def authentication_with_azure_active_directory_form_recognizer_client(self):
"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
# [START create_fr_client_with_aad]
from azure.ai.formrecognizer import FormRecognizerClient
from azure.identity import DefaultAzureCredential
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
credential = DefaultAzureCredential()
form_recognizer_client = FormRecognizerClient(endpoint, credential)
# [END create_fr_client_with_aad]
poller = form_recognizer_client.begin_recognize_receipts_from_url(self.url)
receipt = poller.result()
def test_content_stream_pdf(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
client = FormRecognizerClient(form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with open(self.invoice_pdf, "rb") as fd:
myform = fd.read()
poller = client.begin_recognize_content(myform)
result = poller.result()
self.assertEqual(len(result), 1)
layout = result[0]
self.assertEqual(layout.page_number, 1)
self.assertFormPagesHasValues(result)
self.assertEqual(layout.tables[0].row_count, 2)
self.assertEqual(layout.tables[0].column_count, 6)
self.assertEqual(layout.tables[0].page_number, 1)
def recognize_id_documents(self):
path_to_sample_forms = os.path.abspath(os.path.join(os.path.abspath(__file__),
"..", "./sample_forms/id_documents/license.jpg"))
# [START recognize_id_documents]
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import FormRecognizerClient
endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
form_recognizer_client = FormRecognizerClient(
endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_forms, "rb") as f:
poller = form_recognizer_client.begin_recognize_id_documents(id_document=f)
id_documents = poller.result()
for idx, id_document in enumerate(id_documents):
print("--------Recognizing ID document #{}--------".format(idx+1))
first_name = id_document.fields.get("FirstName")
if first_name:
print("First Name: {} has confidence: {}".format(first_name.value, first_name.confidence))
last_name = id_document.fields.get("LastName")
if last_name:
print("Last Name: {} has confidence: {}".format(last_name.value, last_name.confidence))
document_number = id_document.fields.get("DocumentNumber")
if document_number:
print("Document Number: {} has confidence: {}".format(document_number.value, document_number.confidence))
dob = id_document.fields.get("DateOfBirth")
if dob:
print("Date of Birth: {} has confidence: {}".format(dob.value, dob.confidence))
doe = id_document.fields.get("DateOfExpiration")
if doe:
print("Date of Expiration: {} has confidence: {}".format(doe.value, doe.confidence))
sex = id_document.fields.get("Sex")
if sex:
print("Sex: {} has confidence: {}".format(sex.value_data.text, sex.confidence))
address = id_document.fields.get("Address")
if address:
print("Address: {} has confidence: {}".format(address.value, address.confidence))
# FIXME: uncomment this
# country = id_document.fields.get("Country")
# if country:
# print("Country: {} has confidence: {}".format(country.value, country.confidence))
region = id_document.fields.get("Region")
if region:
print("Region: {} has confidence: {}".format(region.value, region.confidence))
def test_content_continuation_token(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
initial_poller = client.begin_recognize_content_from_url(
self.form_url_jpg)
cont_token = initial_poller.continuation_token()
poller = client.begin_recognize_content_from_url(
self.form_url_jpg, continuation_token=cont_token)
result = poller.result()
self.assertIsNotNone(result)
initial_poller.wait(
) # necessary so azure-devtools doesn't throw assertion error
def main():
try:
# Get configuration settings
load_dotenv()
form_endpoint = os.getenv('FORM_ENDPOINT')
form_key = os.getenv('FORM_KEY')
trainingDataUrl = os.getenv('STORAGE_URL')
# Authenticate Form Training Client
form_recognizer_client = FormRecognizerClient(
form_endpoint, AzureKeyCredential(form_key))
form_training_client = FormTrainingClient(form_endpoint,
AzureKeyCredential(form_key))
# Train model
poller = form_training_client.begin_training(trainingDataUrl,
use_training_labels=False)
model = poller.result()
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))
except Exception as ex:
print(ex)
def main():
try:
# Get configuration settings
form_endpoint = "https://doors1.cognitiveservices.azure.com/"
form_key = "70b2796924584d8da912296e8dea613a"
trainingDataUrl = "https://doors.blob.core.windows.net/treinamento?sp=racwdl&st=2021-05-27T23:44:21Z&se=2021-08-02T07:44:21Z&sv=2020-02-10&sr=c&sig=9Tq5HVWS6Fzq5mHIIklZk3Z1wO%2B5junlwtlNTIFP194%3D"
# Authenticate Form Training Client
form_recognizer_client = FormRecognizerClient(
form_endpoint, AzureKeyCredential(form_key))
form_training_client = FormTrainingClient(form_endpoint,
AzureKeyCredential(form_key))
# Train model
poller = form_training_client.begin_training(trainingDataUrl,
use_training_labels=False)
model = poller.result()
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))
except Exception as ex:
print(ex)
def test_polling_interval(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key),
polling_interval=7)
assert client._client._config.polling_interval == 7
poller = client.begin_recognize_identity_documents_from_url(
self.identity_document_url_jpg, polling_interval=6)
poller.wait()
assert poller._polling_method._timeout == 6
poller2 = client.begin_recognize_identity_documents_from_url(
self.identity_document_url_jpg)
poller2.wait()
assert poller2._polling_method._timeout == 7 # goes back to client default