async def test_custom_form_url_bad_endpoint(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
with self.assertRaises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(form_recognizer_account_key))
poller = await client.begin_recognize_custom_forms_from_url(
model_id="xx", form_url=self.form_url_jpg)
result = await poller.result()
async def test_custom_form_empty_model_id(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with self.assertRaises(ValueError):
async with client:
await client.begin_recognize_custom_forms(model_id="",
form=b"xx")
async def test_authentication_bad_key(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(form_recognizer_account,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
async with client:
poller = await client.begin_recognize_custom_forms(
model_id="xx", form=b"xx", content_type="image/jpeg")
result = await poller.result()
async def test_custom_form_empty_model_id(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
with self.assertRaises(ValueError):
async with client:
await client.begin_recognize_custom_forms_from_url(
model_id="", form_url="https://badurl.jpg")
async def test_url_authentication_bad_key(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(formrecognizer_test_endpoint,
AzureKeyCredential("xxxx"))
with self.assertRaises(ClientAuthenticationError):
async with client:
poller = await client.begin_recognize_custom_forms_from_url(
model_id="xx", form_url=self.form_url_jpg)
result = await poller.result()
async def test_id_document_bad_endpoint(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
with open(self.id_document_jpg, "rb") as fd:
myfile = fd.read()
with self.assertRaises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(formrecognizer_test_api_key))
async with client:
poller = await client.begin_recognize_id_documents(myfile)
async def test_custom_form_none_model_id(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
with self.assertRaises(ValueError):
async with client:
await client.begin_recognize_custom_forms(model_id=None,
form=b"xx")
async 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):
result = await client.recognize_content(
myfile
)
async def test_receipt_url_bad_endpoint(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key):
with self.assertRaises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(formrecognizer_test_api_key))
async with client:
poller = await client.begin_recognize_receipts_from_url(
self.receipt_url_jpg)
result = await poller.result()
async def test_passing_bad_url(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
client = FormRecognizerClient(
form_recognizer_account,
AzureKeyCredential(form_recognizer_account_key))
with self.assertRaises(HttpResponseError):
result = await client.recognize_custom_forms_from_url(
model_id="xx", form_url="https://badurl.jpg")
async def recognize_custom_forms(self):
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer.aio import FormRecognizerClient
path_to_sample_forms = os.path.abspath(
os.path.join(os.path.abspath(__file__), "..", "..",
"./sample_forms/forms/Form_1.jpg"))
async with FormRecognizerClient(
endpoint=self.endpoint, credential=AzureKeyCredential(
self.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:
stream = f.read()
forms_with_labeled_model = await form_recognizer_client.recognize_custom_forms(
model_id=self.model_trained_with_labels_id, form=stream)
forms_with_unlabeled_model = await form_recognizer_client.recognize_custom_forms(
model_id=self.model_trained_without_labels_id, form=stream)
# 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 labels---------"
)
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 without labels-------"
)
for unlabeled_form in forms_with_unlabeled_model:
for name, field in unlabeled_form.fields.items():
# The form recognized with a model trained with unlabeled data will also include data about your labels
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))
async def test_receipt_multipage_transform_url(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)
poller = await client.begin_recognize_receipts_from_url(
self.multipage_url_pdf,
include_text_content=True,
cls=callback
)
result = await poller.result()
raw_response = responses[0]
returned_model = responses[1]
actual = raw_response.analyze_result.document_results
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 hardcoded values
for receipt, actual in zip(returned_model, actual):
if actual.fields is None: # second page is blank
continue
# check dict values
self.assertFormFieldTransformCorrect(receipt.fields.get("MerchantAddress"), actual.fields.get("MerchantAddress"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("MerchantName"), actual.fields.get("MerchantName"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("MerchantPhoneNumber"), actual.fields.get("MerchantPhoneNumber"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Subtotal"), actual.fields.get("Subtotal"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Tax"), actual.fields.get("Tax"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Tip"), actual.fields.get("Tip"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("Total"), actual.fields.get("Total"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("TransactionDate"), actual.fields.get("TransactionDate"), read_results)
self.assertFormFieldTransformCorrect(receipt.fields.get("TransactionTime"), actual.fields.get("TransactionTime"), read_results)
# check page range
self.assertEqual(receipt.page_range.first_page_number, actual.page_range[0])
self.assertEqual(receipt.page_range.last_page_number, actual.page_range[1])
# check receipt type
receipt_type = receipt.fields.get("ReceiptType")
self.assertEqual(receipt_type.confidence, actual.fields["ReceiptType"].confidence)
self.assertEqual(receipt_type.value, actual.fields["ReceiptType"].value_string)
# check receipt items
self.assertReceiptItemsTransformCorrect(receipt.fields["Items"].value, actual.fields["Items"], read_results)
# Check form pages
self.assertFormPagesTransformCorrect(returned_model, read_results)
async def recognize_receipts_from_url(self):
# [START recognize_receipts_from_url_async]
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/main/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+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))
if receipt.fields.get("Items"):
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("--------------------------------------")
async def test_content_url_bad_endpoint(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
with self.assertRaises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(form_recognizer_account_key))
async with client:
poller = await client.begin_recognize_content_from_url(
self.invoice_url_pdf)
result = await poller.result()
async def test_damaged_file_bytes_io_fails_autodetect(
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"\x50\x44\x46\x55\x55\x55"
) # doesn't match any magic file numbers
with self.assertRaises(ValueError):
poller = await client.begin_recognize_receipts(damaged_pdf, )
result = await poller.result()
async 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.receipt_png, "rb") as fd:
myfile = fd.read()
result = await client.recognize_receipts(
myfile, content_type=FormContentType.image_png)
self.assertIsNotNone(result)
async 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 = await client.recognize_receipts(damaged_pdf, )
async 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()
result = await client.recognize_receipts(blank, )
self.assertIsNotNone(result)
async 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):
result = await client.recognize_receipts(
myfile, content_type="application/jpeg")
async def recognize_content(self):
path_to_sample_forms = os.path.abspath(os.path.join(os.path.abspath(__file__),
"..", "..", "./sample_forms/forms/selection_mark_form.pdf"))
# [START recognize_content_async]
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)
form_pages = await 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)
))
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("----------------------------------------")
async def test_content_bad_endpoint(self, resource_group, location,
form_recognizer_account,
form_recognizer_account_key):
with open(self.invoice_pdf, "rb") as fd:
myfile = fd.read()
with self.assertRaises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(form_recognizer_account_key))
poller = await client.begin_recognize_content(myfile)
result = await poller.result()
async 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))
result = await client.recognize_custom_forms(model_id="xx",
stream=myfile)
async def test_content_authentication_bad_key(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key,
**kwargs):
client = FormRecognizerClient(formrecognizer_test_endpoint,
AzureKeyCredential("xxxx"))
with pytest.raises(ClientAuthenticationError):
async with client:
poller = await client.begin_recognize_content(
b"xxx", content_type="application/pdf")
result = await poller.result()
async def test_content_url_pass_stream(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(4) # makes the recording smaller
with self.assertRaises(HttpResponseError):
result = await client.recognize_content_from_url(receipt)
async 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))
result = await client.recognize_content_from_url(self.multipage_url_pdf
)
self.assertEqual(len(result), 3)
self.assertFormPagesHasValues(result)
async 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 = await client.begin_recognize_receipts(
"https://badurl.jpg", content_type="application/json")
result = await poller.result()
async def test_content_bad_endpoint(self, formrecognizer_test_endpoint,
formrecognizer_test_api_key, **kwargs):
with open(self.invoice_pdf, "rb") as fd:
myfile = fd.read()
with pytest.raises(ServiceRequestError):
client = FormRecognizerClient(
"http://notreal.azure.com",
AzureKeyCredential(formrecognizer_test_api_key))
async with client:
poller = await client.begin_recognize_content(myfile)
result = await poller.result()
async def test_authentication_successful_key(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()
poller = await client.begin_recognize_receipts(myfile)
result = await poller.result()
async def test_damaged_file_bytes_io_fails_autodetect(
self, formrecognizer_test_endpoint, formrecognizer_test_api_key):
client = FormRecognizerClient(
formrecognizer_test_endpoint,
AzureKeyCredential(formrecognizer_test_api_key))
damaged_pdf = BytesIO(b"\x50\x44\x46\x55\x55\x55"
) # doesn't match any magic file numbers
with pytest.raises(ValueError):
async with client:
poller = await client.begin_recognize_receipts(damaged_pdf, )
result = await poller.result()
async def test_polling_interval(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
client = FormRecognizerClient(form_recognizer_account, AzureKeyCredential(form_recognizer_account_key), polling_interval=7)
self.assertEqual(client._client._config.polling_interval, 7)
async with client:
poller = await client.begin_recognize_receipts_from_url(self.receipt_url_jpg, polling_interval=6)
await poller.wait()
self.assertEqual(poller._polling_method._timeout, 6)
poller2 = await client.begin_recognize_receipts_from_url(self.receipt_url_jpg)
await poller2.wait()
self.assertEqual(poller2._polling_method._timeout, 7) # goes back to client default
