class BuildModelRequestPreparation(PerfStressTest): def __init__(self, arguments): super().__init__(arguments) # read test related env vars self.formrecognizer_storage_container_sas_url = os.environ["FORMRECOGNIZER_TRAINING_DATA_CONTAINER_SAS_URL"] formrecognizer_test_endpoint = os.environ["FORMRECOGNIZER_TEST_ENDPOINT"] form_recognizer_account_key = os.environ["FORMRECOGNIZER_TEST_API_KEY"] # assign the clients that will be used in the perf tests self.admin_client = DocumentModelAdministrationClient(formrecognizer_test_endpoint, AzureKeyCredential(form_recognizer_account_key)) self.async_admin_client = AsyncDocumentModelAdministrationClient(formrecognizer_test_endpoint, AzureKeyCredential(form_recognizer_account_key)) async def close(self): """This is run after cleanup.""" await self.async_admin_client.close() self.admin_client.close() await super().close() def run_sync(self): """The synchronous perf test.""" poller = self.admin_client.begin_build_model(self.formrecognizer_storage_container_sas_url) assert poller async def run_async(self): """The asynchronous perf test.""" poller = await self.async_admin_client.begin_build_model(self.formrecognizer_storage_container_sas_url) assert poller
def test_build_model_auth_bad_key(self, formrecognizer_test_endpoint, formrecognizer_test_api_key, **kwargs): set_bodiless_matcher() client = DocumentModelAdministrationClient( formrecognizer_test_endpoint, AzureKeyCredential("xxxx")) with pytest.raises(ClientAuthenticationError): poller = client.begin_build_model("xx")
def sample_build_model(): # [START build_model] from azure.ai.formrecognizer import DocumentModelAdministrationClient, DocumentBuildMode 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"] document_model_admin_client = DocumentModelAdministrationClient(endpoint, AzureKeyCredential(key)) poller = document_model_admin_client.begin_build_model( container_sas_url, DocumentBuildMode.TEMPLATE, description="my model description" ) model = poller.result() print("Model ID: {}".format(model.model_id)) print("Description: {}".format(model.description)) print("Model created on: {}\n".format(model.created_on)) print("Doc types the model can recognize:") for name, doc_type in model.doc_types.items(): print("\nDoc Type: '{}' built with '{}' mode which has the following fields:".format(name, doc_type.build_mode)) for field_name, field in doc_type.field_schema.items(): print("Field: '{}' has type '{}' and confidence score {}".format( field_name, field["type"], doc_type.field_confidence[field_name] ))
async def test_get_document_analysis_client(self, formrecognizer_test_endpoint, formrecognizer_test_api_key, **kwargs): # this can be reverted to set_bodiless_matcher() after tests are re-recorded and don't contain these headers set_custom_default_matcher( compare_bodies=False, excluded_headers= "Authorization,Content-Length,x-ms-client-request-id,x-ms-request-id" ) transport = AioHttpTransport() dtc = DocumentModelAdministrationClient( endpoint=formrecognizer_test_endpoint, credential=AzureKeyCredential(formrecognizer_test_api_key), transport=transport) async with dtc: await dtc.get_account_info() assert transport.session is not None async with dtc.get_document_analysis_client() as dac: assert transport.session is not None await (await dac.begin_analyze_document_from_url( "prebuilt-receipt", self.receipt_url_jpg)).wait() assert dac._api_version == DocumentAnalysisApiVersion.V2022_01_30_PREVIEW await dtc.get_account_info() assert transport.session is not None
def test_build_model_auth_bad_key(self, formrecognizer_test_endpoint, formrecognizer_test_api_key, **kwargs): # this can be reverted to set_bodiless_matcher() after tests are re-recorded and don't contain these headers set_custom_default_matcher( compare_bodies=False, excluded_headers="Authorization,Content-Length,x-ms-client-request-id,x-ms-request-id" ) client = DocumentModelAdministrationClient(formrecognizer_test_endpoint, AzureKeyCredential("xxxx")) with pytest.raises(ClientAuthenticationError): poller = client.begin_build_model("xx", build_mode="template")
def test_dmac_auth_bad_key(self, formrecognizer_test_endpoint, formrecognizer_test_api_key, **kwargs): client = DocumentModelAdministrationClient( formrecognizer_test_endpoint, AzureKeyCredential("xxxx")) with pytest.raises(ClientAuthenticationError): result = client.get_account_info() return {}
def __init__(self, arguments): super().__init__(arguments) # read test related env vars self.formrecognizer_storage_container_sas_url = os.environ["FORMRECOGNIZER_TRAINING_DATA_CONTAINER_SAS_URL"] formrecognizer_test_endpoint = os.environ["FORMRECOGNIZER_TEST_ENDPOINT"] form_recognizer_account_key = os.environ["FORMRECOGNIZER_TEST_API_KEY"] # assign the clients that will be used in the perf tests self.admin_client = DocumentModelAdministrationClient(formrecognizer_test_endpoint, AzureKeyCredential(form_recognizer_account_key)) self.async_admin_client = AsyncDocumentModelAdministrationClient(formrecognizer_test_endpoint, AzureKeyCredential(form_recognizer_account_key))
def authentication_with_api_key_credential_document_model_admin_client(): # [START create_dt_client_with_key] from azure.core.credentials import AzureKeyCredential from azure.ai.formrecognizer import DocumentModelAdministrationClient endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"] key = os.environ["AZURE_FORM_RECOGNIZER_KEY"] document_model_admin_client = DocumentModelAdministrationClient(endpoint, AzureKeyCredential(key)) # [END create_dt_client_with_key] info = document_model_admin_client.get_account_info()
def sample_manage_models(): from azure.core.credentials import AzureKeyCredential from azure.core.exceptions import ResourceNotFoundError from azure.ai.formrecognizer import DocumentModelAdministrationClient, DocumentBuildMode endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"] key = os.environ["AZURE_FORM_RECOGNIZER_KEY"] container_sas_url = os.environ["CONTAINER_SAS_URL"] # [START get_account_info] document_model_admin_client = DocumentModelAdministrationClient( endpoint=endpoint, credential=AzureKeyCredential(key)) account_info = document_model_admin_client.get_account_info() print( "Our account has {} custom models, and we can have at most {} custom models\n" .format(account_info.document_model_count, account_info.document_model_limit)) # [END get_account_info] # Next, we get a paged list of all of our custom models # [START list_models] models = document_model_admin_client.list_models() print("We have the following 'ready' models with IDs and descriptions:") for model in models: print("{} | {}".format(model.model_id, model.description)) # [END list_models] # let's build a model to use for this sample poller = document_model_admin_client.begin_build_model( container_sas_url, DocumentBuildMode.TEMPLATE, description="model for sample") model = poller.result() # [START get_model] my_model = document_model_admin_client.get_model(model_id=model.model_id) print("\nModel ID: {}".format(my_model.model_id)) print("Description: {}".format(my_model.description)) print("Model created on: {}".format(my_model.created_on)) # [END get_model] # Finally, we will delete this model by ID # [START delete_model] document_model_admin_client.delete_model(model_id=my_model.model_id) try: document_model_admin_client.get_model(model_id=my_model.model_id) except ResourceNotFoundError: print("Successfully deleted model with ID {}".format( my_model.model_id))
def authentication_with_azure_active_directory_document_model_admin_client(): # [START create_dt_client_with_aad] """DefaultAzureCredential will use the values from these environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET """ from azure.ai.formrecognizer import DocumentModelAdministrationClient from azure.identity import DefaultAzureCredential endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"] credential = DefaultAzureCredential() document_model_admin_client = DocumentModelAdministrationClient(endpoint, credential) # [END create_dt_client_with_aad] info = document_model_admin_client.get_account_info()
async def test_active_directory_auth_async(self): token = self.generate_oauth_token() endpoint = self.get_oauth_endpoint() client = DocumentModelAdministrationClient(endpoint, token) async with client: info = await client.get_account_info() assert info
def test_form_api_version_document_model_admin_client(self): with pytest.raises(ValueError) as excinfo: client = DocumentModelAdministrationClient( "url", "key", api_version=FormRecognizerApiVersion.V2_1) assert "Unsupported API version '2.1'. Please select from: {}\nAPI version '2.1' is " \ "only available for FormRecognizerClient and FormTrainingClient.".format( ", ".join(v.value for v in DocumentAnalysisApiVersion)) == str(excinfo.value)
def test_bad_api_version_document_model_admin_client(self): with pytest.raises(ValueError) as excinfo: client = DocumentModelAdministrationClient("url", "key", api_version="9") assert "Unsupported API version '9'. Please select from: {}".format( ", ".join(v.value for v in DocumentAnalysisApiVersion)) == str( excinfo.value)
def sample_get_operations(): # [START list_operations] from azure.core.credentials import AzureKeyCredential from azure.ai.formrecognizer import DocumentModelAdministrationClient endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"] key = os.environ["AZURE_FORM_RECOGNIZER_KEY"] document_model_admin_client = DocumentModelAdministrationClient( endpoint=endpoint, credential=AzureKeyCredential(key)) operations = list(document_model_admin_client.list_operations()) print("The following document model operations exist under my resource:") for operation in operations: print("\nOperation ID: {}".format(operation.operation_id)) print("Operation kind: {}".format(operation.kind)) print("Operation status: {}".format(operation.status)) print("Operation percent completed: {}".format( operation.percent_completed)) print("Operation created on: {}".format(operation.created_on)) print("Operation last updated on: {}".format( operation.last_updated_on)) print("Resource location of successful operation: {}".format( operation.resource_location)) # [END list_operations] # [START get_operation] # Get an operation by ID if operations: print("\nGetting operation info by ID: {}".format( operations[0].operation_id)) operation_info = document_model_admin_client.get_operation( operations[0].operation_id) if operation_info.status == "succeeded": print("My {} operation is completed.".format(operation_info.kind)) result = operation_info.result print("Model ID: {}".format(result.model_id)) elif operation_info.status == "failed": print("My {} operation failed.".format(operation_info.kind)) error = operation_info.error print("{}: {}".format(error.code, error.message)) else: print("My operation status is {}".format(operation_info.status)) else: print("No operations found.")
async def test_get_document_analysis_client(self, formrecognizer_test_endpoint, formrecognizer_test_api_key): transport = AioHttpTransport() dtc = DocumentModelAdministrationClient( endpoint=formrecognizer_test_endpoint, credential=AzureKeyCredential(formrecognizer_test_api_key), transport=transport) async with dtc: await dtc.get_account_info() assert transport.session is not None async with dtc.get_document_analysis_client() as dac: assert transport.session is not None await (await dac.begin_analyze_document_from_url( "prebuilt-receipt", self.receipt_url_jpg)).wait() assert dac._api_version == DocumentAnalysisApiVersion.V2021_09_30_PREVIEW await dtc.get_account_info() assert transport.session is not None
def test_logging_info_dmac_client(self, formrecognizer_test_endpoint, formrecognizer_test_api_key): client = DocumentModelAdministrationClient( formrecognizer_test_endpoint, AzureKeyCredential(formrecognizer_test_api_key)) mock_handler = MockHandler() logger = logging.getLogger("azure") logger.addHandler(mock_handler) logger.setLevel(logging.INFO) result = client.get_account_info() for message in mock_handler.messages: if message.levelname == "INFO": # not able to use json.loads here. At INFO level only API key should be REDACTED if message.message.find("Ocp-Apim-Subscription-Key") != -1: assert message.message.find("REDACTED") != -1 else: assert message.message.find("REDACTED") == -1
def sample_create_composed_model(): # [START composed_model] from azure.core.credentials import AzureKeyCredential from azure.ai.formrecognizer import DocumentModelAdministrationClient, DocumentBuildMode endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"] key = os.environ["AZURE_FORM_RECOGNIZER_KEY"] po_supplies = os.environ['PURCHASE_ORDER_OFFICE_SUPPLIES_SAS_URL'] po_equipment = os.environ['PURCHASE_ORDER_OFFICE_EQUIPMENT_SAS_URL'] po_furniture = os.environ['PURCHASE_ORDER_OFFICE_FURNITURE_SAS_URL'] po_cleaning_supplies = os.environ[ 'PURCHASE_ORDER_OFFICE_CLEANING_SUPPLIES_SAS_URL'] document_model_admin_client = DocumentModelAdministrationClient( endpoint=endpoint, credential=AzureKeyCredential(key)) supplies_poller = document_model_admin_client.begin_build_model( po_supplies, DocumentBuildMode.TEMPLATE, description="Purchase order-Office supplies") equipment_poller = document_model_admin_client.begin_build_model( po_equipment, DocumentBuildMode.TEMPLATE, description="Purchase order-Office Equipment") furniture_poller = document_model_admin_client.begin_build_model( po_furniture, DocumentBuildMode.TEMPLATE, description="Purchase order-Furniture") cleaning_supplies_poller = document_model_admin_client.begin_build_model( po_cleaning_supplies, DocumentBuildMode.TEMPLATE, description="Purchase order-Cleaning Supplies") supplies_model = supplies_poller.result() equipment_model = equipment_poller.result() furniture_model = furniture_poller.result() cleaning_supplies_model = cleaning_supplies_poller.result() purchase_order_models = [ supplies_model.model_id, equipment_model.model_id, furniture_model.model_id, cleaning_supplies_model.model_id ] poller = document_model_admin_client.begin_create_composed_model( purchase_order_models, description="Office Supplies Composed Model") model = poller.result() print("Office Supplies Composed Model Info:") print("Model ID: {}".format(model.model_id)) print("Description: {}".format(model.description)) print("Model created on: {}\n".format(model.created_on)) print("Doc types the model can recognize:") for name, doc_type in model.doc_types.items(): print("\nDoc Type: '{}' which has the following fields:".format(name)) for field_name, field in doc_type.field_schema.items(): print("Field: '{}' has type '{}' and confidence score {}".format( field_name, field["type"], doc_type.field_confidence[field_name]))
def sample_copy_model(custom_model_id): # [START begin_copy_model] from azure.core.credentials import AzureKeyCredential from azure.ai.formrecognizer import DocumentModelAdministrationClient source_endpoint = os.environ["AZURE_FORM_RECOGNIZER_SOURCE_ENDPOINT"] source_key = os.environ["AZURE_FORM_RECOGNIZER_SOURCE_KEY"] target_endpoint = os.environ["AZURE_FORM_RECOGNIZER_TARGET_ENDPOINT"] target_key = os.environ["AZURE_FORM_RECOGNIZER_TARGET_KEY"] source_model_id = os.getenv("AZURE_SOURCE_MODEL_ID", custom_model_id) target_client = DocumentModelAdministrationClient(endpoint=target_endpoint, credential=AzureKeyCredential(target_key)) target = target_client.get_copy_authorization( description="model copied from other resource" ) source_client = DocumentModelAdministrationClient(endpoint=source_endpoint, credential=AzureKeyCredential(source_key)) poller = 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 = poller.result() print("Model ID: {}".format(model.model_id)) print("Description: {}".format(model.description)) print("Model created on: {}\n".format(model.created_on)) print("Doc types the model can recognize:") for name, doc_type in model.doc_types.items(): print("\nDoc Type: '{}' which has the following fields:".format(name)) for field_name, field in doc_type.field_schema.items(): print("Field: '{}' has type '{}' and confidence score {}".format( field_name, field["type"], doc_type.field_confidence[field_name] ))
def test_get_document_analysis_client(self, formrecognizer_test_endpoint, formrecognizer_test_api_key, **kwargs): set_bodiless_matcher() transport = RequestsTransport() dtc = DocumentModelAdministrationClient( endpoint=formrecognizer_test_endpoint, credential=AzureKeyCredential(formrecognizer_test_api_key), transport=transport) with dtc: dtc.get_account_info() assert transport.session is not None with dtc.get_document_analysis_client() as dac: assert transport.session is not None dac.begin_analyze_document_from_url( "prebuilt-receipt", self.receipt_url_jpg).wait() assert dac._api_version == DocumentAnalysisApiVersion.V2021_09_30_PREVIEW dtc.get_account_info() assert transport.session is not None
print("...{}".format(i + 1, region.page_number)) for cell in table.cells: print("...Cell[{}][{}] has content '{}'".format( cell.row_index, cell.column_index, cell.content)) print("-----------------------------------") # [END analyze_custom_documents] if __name__ == "__main__": model_id = None if os.getenv("CONTAINER_SAS_URL"): from azure.core.credentials import AzureKeyCredential from azure.ai.formrecognizer import DocumentModelAdministrationClient, DocumentBuildMode endpoint = os.getenv("AZURE_FORM_RECOGNIZER_ENDPOINT") key = os.getenv("AZURE_FORM_RECOGNIZER_KEY") if not endpoint or not key: raise ValueError( "Please provide endpoint and API key to run the samples.") document_model_admin_client = DocumentModelAdministrationClient( endpoint=endpoint, credential=AzureKeyCredential(key)) model = document_model_admin_client.begin_build_model( os.getenv("CONTAINER_SAS_URL"), DocumentBuildMode.TEMPLATE).result() model_id = model.model_id analyze_custom_documents(model_id)