Azure Formigenkänning-klientbibliotek för Python – version 3.3.2

Azure Document Intelligence (tidigare kallat Formigenkänning) är en molntjänst som använder maskininlärning för att analysera text och strukturerade data från dina dokument. Den innehåller följande huvudfunktioner:

• Layout – Extrahera innehåll och struktur (t.ex. ord, markeringar, tabeller) från dokument.
• Dokument – Analysera nyckel/värde-par utöver allmän layout från dokument.
• Läs – Läs sidinformation från dokument.
• Fördefinierad – Extrahera vanliga fältvärden från utvalda dokumenttyper (t.ex. kvitton, fakturor, visitkort, ID-dokument, amerikanska W-2-skattedokument, bland annat) med hjälp av fördefinierade modeller.
• Anpassad – Skapa anpassade modeller från dina egna data för att extrahera anpassade fältvärden utöver allmän layout från dokument.
• Klassificerare – Skapa anpassade klassificeringsmodeller som kombinerar layout- och språkfunktioner för att korrekt identifiera och identifiera dokument som du bearbetar i ditt program.
• Tilläggsfunktioner – Extrahera streckkoder/QR-koder, formler, teckensnitt/format osv. eller aktivera högupplösningsläge för stora dokument med valfria parametrar.

Källkod | Paket (PyPI) | Paket (Conda) | API-referensdokumentation | Produktdokumentation | Prover

Komma igång

Förutsättningar

• Python 3.7 eller senare krävs för att använda det här paketet.
• Du måste ha en Azure-prenumeration och en Cognitive Services- eller Formigenkänning resurs för att kunna använda det här paketet.

Installera paketet

Installera Azure Formigenkänning-klientbiblioteket för Python med pip:

pip install azure-ai-formrecognizer

Obs! Den här versionen av klientbiblioteket är standard för 2023-07-31 tjänstens version.

Den här tabellen visar relationen mellan SDK-versioner och API-versioner som stöds av tjänsten:

Obs! Från och med version 3.2.Xintroducerades en ny uppsättning klienter för att utnyttja de senaste funktionerna i dokumentunderrättelsetjänsten. Se migreringsguiden för detaljerade instruktioner om hur du uppdaterar programkod från klientbibliotekets version 3.1.X eller lägre till den senaste versionen. Mer detaljerad information finns i Ändringsloggen . I tabellen nedan beskrivs relationen mellan varje klient och dess API-versioner som stöds:

Skapa en Cognitive Services- eller Formigenkänning resurs

Dokumentinformation stöder både åtkomst med flera tjänster och en enda tjänst. Skapa en Cognitive Services-resurs om du planerar att komma åt flera kognitiva tjänster under en enda slutpunkt/nyckel. För endast åtkomst till dokumentinformation skapar du en Formigenkänning resurs. Observera att du behöver en resurs med en enda tjänst om du tänker använda Azure Active Directory-autentisering.

Du kan skapa någon av resurserna med hjälp av:

• Alternativ 1: Azure Portal.
• Alternativ 2: Azure CLI.

Nedan visas ett exempel på hur du kan skapa en Formigenkänning resurs med hjälp av CLI:

# Create a new resource group to hold the Form Recognizer resource
# if using an existing resource group, skip this step
az group create --name <your-resource-name> --location <location>

# Create form recognizer
az cognitiveservices account create \
    --name <your-resource-name> \
    --resource-group <your-resource-group-name> \
    --kind FormRecognizer \
    --sku <sku> \
    --location <location> \
    --yes

Mer information om hur du skapar resursen eller hur du hämtar plats- och sku-information finns här.

Autentisera klienten

För att kunna interagera med dokumentunderrättelsetjänsten måste du skapa en instans av en klient. En slutpunkt och autentiseringsuppgifter krävs för att instansiera klientobjektet.

Hämta slutpunkten

Du hittar slutpunkten för din Formigenkänning resurs med hjälp av Azure-portalen eller Azure CLI:

# Get the endpoint for the Form Recognizer resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Antingen kan en regional slutpunkt eller en anpassad underdomän användas för autentisering. De är formaterade på följande sätt:

Regional endpoint: https://<region>.api.cognitive.microsoft.com/
Custom subdomain: https://<resource-name>.cognitiveservices.azure.com/

En regional slutpunkt är densamma för varje resurs i en region. En fullständig lista över regionala slutpunkter som stöds kan konsulteras här. Observera att regionala slutpunkter inte stöder AAD-autentisering.

En anpassad underdomän är å andra sidan ett namn som är unikt för den Formigenkänning resursen. De kan bara användas av resurser med en enda tjänst.

Hämta API-nyckeln

API-nyckeln finns i Azure-portalen eller genom att köra följande Azure CLI-kommando:

az cognitiveservices account keys list --name "<resource-name>" --resource-group "<resource-group-name>"

Skapa klienten med AzureKeyCredential

Om du vill använda en API-nyckel som credential parameter skickar du nyckeln som en sträng till en instans av AzureKeyCredential.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")
document_analysis_client = DocumentAnalysisClient(endpoint, credential)

Skapa klienten med en Azure Active Directory-autentiseringsuppgift

AzureKeyCredential autentisering används i exemplen i den här komma igång-guiden, men du kan också autentisera med Azure Active Directory med hjälp av azure-identity-biblioteket . Observera att regionala slutpunkter inte stöder AAD-autentisering. Skapa ett anpassat underdomännamn för resursen för att använda den här typen av autentisering.

Om du vill använda typen DefaultAzureCredential som visas nedan eller andra typer av autentiseringsuppgifter som medföljer Azure SDK installerar azure-identity du paketet:

pip install azure-identity

Du måste också registrera ett nytt AAD-program och bevilja åtkomst till Dokumentinformation genom att "Cognitive Services User" tilldela rollen till tjänstens huvudnamn.

När du är klar anger du värdena för klient-ID, klient-ID och klienthemlighet för AAD-programmet som miljövariabler: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

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

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

document_analysis_client = DocumentAnalysisClient(endpoint, credential)

Viktiga begrepp

DocumentAnalysisClient

DocumentAnalysisClient innehåller åtgärder för att analysera indatadokument med hjälp av fördefinierade och anpassade modeller via API:erna begin_analyze_document och begin_analyze_document_from_url . Använd parametern model_id för att välja typ av modell för analys. Se en fullständig lista över modeller som stöds här. Innehåller DocumentAnalysisClient även åtgärder för att klassificera dokument via API:erna begin_classify_document och begin_classify_document_from_url . Anpassade klassificeringsmodeller kan klassificera varje sida i en indatafil för att identifiera dokument i och kan även identifiera flera dokument eller flera instanser av ett enskilt dokument i en indatafil.

Exempelkodfragment tillhandahålls för att illustrera med hjälp av ett DocumentAnalysisClient-exempel här. Mer information om att analysera dokument, inklusive funktioner, nationella inställningar och dokumenttyper som stöds finns i tjänstdokumentationen.

DocumentModelAdministrationClient

DocumentModelAdministrationClient tillhandahåller åtgärder för:

• Skapa anpassade modeller för att analysera specifika fält som du anger genom att märka dina anpassade dokument. En DocumentModelDetails returneras som anger de dokumenttyper som modellen kan analysera, samt den uppskattade konfidensen för varje fält. Mer detaljerad förklaring finns i tjänstdokumentationen .
• Skapa en sammansatt modell från en samling befintliga modeller.
• Hantera modeller som skapats i ditt konto.
• Visa åtgärder eller hämta en specifik modellåtgärd som skapats under de senaste 24 timmarna.
• Kopiera en anpassad modell från en Formigenkänning resurs till en annan.
• Skapa och hantera en anpassad klassificeringsmodell för att klassificera de dokument som du bearbetar i ditt program.

Observera att modeller också kan skapas med hjälp av ett grafiskt användargränssnitt, till exempel Document Intelligence Studio.

Exempelkodfragment tillhandahålls för att illustrera med hjälp av ett DocumentModelAdministrationClient-exempel här.

Långvariga åtgärder

Långvariga åtgärder är åtgärder som består av en första begäran som skickas till tjänsten för att starta en åtgärd, följt av avsökning av tjänsten med jämna mellanrum för att avgöra om åtgärden har slutförts eller misslyckats, och om den har lyckats för att få resultatet.

Metoder som analyserar dokument, byggmodeller eller kopierar/skriver modeller modelleras som långvariga åtgärder. Klienten exponerar en begin_<method-name> metod som returnerar en LROPoller eller AsyncLROPoller. Anropare bör vänta tills åtgärden har slutförts genom att anropa result() det pollerobjekt som returneras från begin_<method-name> metoden . Exempelkodfragment tillhandahålls för att illustrera med hjälp av långvariga åtgärder nedan.

Exempel

Följande avsnitt innehåller flera kodfragment som täcker några av de vanligaste uppgifterna för dokumentinformation, inklusive:

• Extrahera layout
• Använda den allmänna dokumentmodellen
• Använda fördefinierade modeller
• Skapa en anpassad modell
• Analysera dokument med en anpassad modell
• Hantera dina modeller
• Klassificera dokument
• Tilläggsfunktioner

Extrahera layout

Extrahera text, markeringsmarkeringar, textformat och tabellstrukturer, tillsammans med deras koordinater för avgränsningsområde, från dokument.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

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

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-layout", document=f
    )
result = poller.result()

for idx, style in enumerate(result.styles):
    print(
        "Document contains {} content".format(
            "handwritten" if style.is_handwritten else "no handwritten"
        )
    )

for page in result.pages:
    print("----Analyzing layout from page #{}----".format(page.page_number))
    print(
        "Page has width: {} and height: {}, measured with unit: {}".format(
            page.width, page.height, page.unit
        )
    )

    for line_idx, line in enumerate(page.lines):
        words = line.get_words()
        print(
            "...Line # {} has word count {} and text '{}' within bounding polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                line.polygon,
            )
        )

        for word in words:
            print(
                "......Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

    for selection_mark in page.selection_marks:
        print(
            "...Selection mark is '{}' within bounding polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                selection_mark.polygon,
                selection_mark.confidence,
            )
        )

for table_idx, table in enumerate(result.tables):
    print(
        "Table # {} has {} rows and {} columns".format(
            table_idx, table.row_count, table.column_count
        )
    )
    for region in table.bounding_regions:
        print(
            "Table # {} location on page: {} is {}".format(
                table_idx,
                region.page_number,
                region.polygon,
            )
        )
    for cell in table.cells:
        print(
            "...Cell[{}][{}] has content '{}'".format(
                cell.row_index,
                cell.column_index,
                cell.content,
            )
        )
        for region in cell.bounding_regions:
            print(
                "...content on page {} is within bounding polygon '{}'".format(
                    region.page_number,
                    region.polygon,
                )
            )

print("----------------------------------------")

Använda den allmänna dokumentmodellen

Analysera nyckel/värde-par, tabeller, format och urvalsmarkeringar från dokument med hjälp av den allmänna dokumentmodellen som tillhandahålls av dokumentinformationstjänsten. Välj den allmänna dokumentmodellen genom att skicka model_id="prebuilt-document" till begin_analyze_document metoden :

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

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

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-document", document=f
    )
result = poller.result()

for style in result.styles:
    if style.is_handwritten:
        print("Document contains handwritten content: ")
        print(",".join([result.content[span.offset:span.offset + span.length] for span in style.spans]))

print("----Key-value pairs found in document----")
for kv_pair in result.key_value_pairs:
    if kv_pair.key:
        print(
                "Key '{}' found within '{}' bounding regions".format(
                    kv_pair.key.content,
                    kv_pair.key.bounding_regions,
                )
            )
    if kv_pair.value:
        print(
                "Value '{}' found within '{}' bounding regions\n".format(
                    kv_pair.value.content,
                    kv_pair.value.bounding_regions,
                )
            )

for page in result.pages:
    print("----Analyzing document from page #{}----".format(page.page_number))
    print(
        "Page has width: {} and height: {}, measured with unit: {}".format(
            page.width, page.height, page.unit
        )
    )

    for line_idx, line in enumerate(page.lines):
        words = line.get_words()
        print(
            "...Line # {} has {} words and text '{}' within bounding polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                line.polygon,
            )
        )

        for word in words:
            print(
                "......Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

    for selection_mark in page.selection_marks:
        print(
            "...Selection mark is '{}' within bounding polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                selection_mark.polygon,
                selection_mark.confidence,
            )
        )

for table_idx, table in enumerate(result.tables):
    print(
        "Table # {} has {} rows and {} columns".format(
            table_idx, table.row_count, table.column_count
        )
    )
    for region in table.bounding_regions:
        print(
            "Table # {} location on page: {} is {}".format(
                table_idx,
                region.page_number,
                region.polygon,
            )
        )
    for cell in table.cells:
        print(
            "...Cell[{}][{}] has content '{}'".format(
                cell.row_index,
                cell.column_index,
                cell.content,
            )
        )
        for region in cell.bounding_regions:
            print(
                "...content on page {} is within bounding polygon '{}'\n".format(
                    region.page_number,
                    region.polygon,
                )
            )
print("----------------------------------------")

• Läs mer om de funktioner som tillhandahålls av prebuilt-document modellen här.

Använda fördefinierade modeller

Extrahera fält från utvalda dokumenttyper, till exempel kvitton, fakturor, visitkort, identitetsdokument och amerikanska W-2-skattedokument med hjälp av fördefinierade modeller som tillhandahålls av dokumentinformationstjänsten.

Om du till exempel vill analysera fält från ett försäljningskvitto använder du den fördefinierade kvittomodellen som tillhandahålls genom att skicka model_id="prebuilt-receipt" till begin_analyze_document metoden :

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

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

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-receipt", document=f, locale="en-US"
    )
receipts = poller.result()

for idx, receipt in enumerate(receipts.documents):
    print(f"--------Analysis of receipt #{idx + 1}--------")
    print(f"Receipt type: {receipt.doc_type if receipt.doc_type else 'N/A'}")
    merchant_name = receipt.fields.get("MerchantName")
    if merchant_name:
        print(
            f"Merchant Name: {merchant_name.value} has confidence: "
            f"{merchant_name.confidence}"
        )
    transaction_date = receipt.fields.get("TransactionDate")
    if transaction_date:
        print(
            f"Transaction Date: {transaction_date.value} has confidence: "
            f"{transaction_date.confidence}"
        )
    if receipt.fields.get("Items"):
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").value):
            print(f"...Item #{idx + 1}")
            item_description = item.value.get("Description")
            if item_description:
                print(
                    f"......Item Description: {item_description.value} has confidence: "
                    f"{item_description.confidence}"
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    f"......Item Quantity: {item_quantity.value} has confidence: "
                    f"{item_quantity.confidence}"
                )
            item_price = item.value.get("Price")
            if item_price:
                print(
                    f"......Individual Item Price: {item_price.value} has confidence: "
                    f"{item_price.confidence}"
                )
            item_total_price = item.value.get("TotalPrice")
            if item_total_price:
                print(
                    f"......Total Item Price: {item_total_price.value} has confidence: "
                    f"{item_total_price.confidence}"
                )
    subtotal = receipt.fields.get("Subtotal")
    if subtotal:
        print(f"Subtotal: {subtotal.value} has confidence: {subtotal.confidence}")
    tax = receipt.fields.get("TotalTax")
    if tax:
        print(f"Total tax: {tax.value} has confidence: {tax.confidence}")
    tip = receipt.fields.get("Tip")
    if tip:
        print(f"Tip: {tip.value} has confidence: {tip.confidence}")
    total = receipt.fields.get("Total")
    if total:
        print(f"Total: {total.value} has confidence: {total.confidence}")
    print("--------------------------------------")

Du är inte begränsad till kvitton! Det finns några fördefinierade modeller att välja mellan, där var och en har en egen uppsättning fält som stöds. Se andra fördefinierade modeller som stöds här.

Skapa en anpassad modell

Skapa en anpassad modell på din egen dokumenttyp. Den resulterande modellen kan användas för att analysera värden från de typer av dokument som den har tränats på. Ange en CONTAINER-SAS-URL till din Azure Storage Blob-container där du lagrar träningsdokumenten.

Mer information om hur du konfigurerar en container och nödvändig filstruktur finns i tjänstdokumentationen.

from azure.ai.formrecognizer import (
    DocumentModelAdministrationClient,
    ModelBuildMode,
)
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_document_model(
    ModelBuildMode.TEMPLATE,
    blob_container_url=container_sas_url,
    description="my model description",
)
model = poller.result()

print(f"Model ID: {model.model_id}")
print(f"Description: {model.description}")
print(f"Model created on: {model.created_on}")
print(f"Model expires on: {model.expires_on}")
print("Doc types the model can recognize:")
for name, doc_type in model.doc_types.items():
    print(
        f"Doc Type: '{name}' built with '{doc_type.build_mode}' mode which has the following fields:"
    )
    for field_name, field in doc_type.field_schema.items():
        print(
            f"Field: '{field_name}' has type '{field['type']}' and confidence score "
            f"{doc_type.field_confidence[field_name]}"
        )

Analysera dokument med en anpassad modell

Analysera dokumentfält, tabeller, urvalsmarkeringar med mera. Dessa modeller tränas med dina egna data, så de är skräddarsydda för dina dokument. För bästa resultat bör du bara analysera dokument av samma dokumenttyp som den anpassade modellen skapades med.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
model_id = os.getenv("CUSTOM_BUILT_MODEL_ID", custom_model_id)

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)

# Make sure your document's type is included in the list of document types the custom model can analyze
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        model_id=model_id, document=f
    )
result = poller.result()

for idx, document in enumerate(result.documents):
    print(f"--------Analyzing document #{idx + 1}--------")
    print(f"Document has type {document.doc_type}")
    print(f"Document has document type confidence {document.confidence}")
    print(f"Document was analyzed with model with ID {result.model_id}")
    for name, field in document.fields.items():
        field_value = field.value if field.value else field.content
        print(
            f"......found field of type '{field.value_type}' with value '{field_value}' and with confidence {field.confidence}"
        )

# iterate over tables, lines, and selection marks on each page
for page in result.pages:
    print(f"\nLines found on page {page.page_number}")
    for line in page.lines:
        print(f"...Line '{line.content}'")
    for word in page.words:
        print(f"...Word '{word.content}' has a confidence of {word.confidence}")
    if page.selection_marks:
        print(f"\nSelection marks found on page {page.page_number}")
        for selection_mark in page.selection_marks:
            print(
                f"...Selection mark is '{selection_mark.state}' and has a confidence of {selection_mark.confidence}"
            )

for i, table in enumerate(result.tables):
    print(f"\nTable {i + 1} can be found on page:")
    for region in table.bounding_regions:
        print(f"...{region.page_number}")
    for cell in table.cells:
        print(
            f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'"
        )
print("-----------------------------------")

Du kan också använda en dokument-URL för att analysera dokument med hjälp av begin_analyze_document_from_url metoden .

document_url = "<url_of_the_document>"
poller = document_analysis_client.begin_analyze_document_from_url(model_id=model_id, document_url=document_url)
result = poller.result()

Hantera dina modeller

Hantera de anpassade modeller som är kopplade till ditt konto.

from azure.ai.formrecognizer import DocumentModelAdministrationClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")

document_model_admin_client = DocumentModelAdministrationClient(endpoint, credential)

account_details = document_model_admin_client.get_resource_details()
print("Our account has {} custom models, and we can have at most {} custom models".format(
    account_details.custom_document_models.count, account_details.custom_document_models.limit
))

# Here we get a paged list of all of our models
models = document_model_admin_client.list_document_models()
print("We have models with the following ids: {}".format(
    ", ".join([m.model_id for m in models])
))

# Replace with the custom model ID from the "Build a model" sample
model_id = "<model_id from the Build a Model sample>"

custom_model = document_model_admin_client.get_document_model(model_id=model_id)
print("Model ID: {}".format(custom_model.model_id))
print("Description: {}".format(custom_model.description))
print("Model created on: {}\n".format(custom_model.created_on))

# Finally, we will delete this model by ID
document_model_admin_client.delete_document_model(model_id=custom_model.model_id)

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

Tilläggsfunktioner

Dokumentinformation har stöd för mer avancerade analysfunktioner. Dessa valfria funktioner kan aktiveras och inaktiveras beroende på scenariot för extrahering av dokument.

Följande tilläggsfunktioner är tillgängliga för 2023-07-31 (GA) och senare versioner:

• streckkod/QR-kod
• Formel
• teckensnitt/formatmall
• högupplösningsläge
• Språk

Observera att vissa tilläggsfunktioner medför ytterligare avgifter. Se priser: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Felsökning

Allmänt

Formigenkänning klientbibliotek skapar undantag som definierats i Azure Core. Felkoder och meddelanden som genereras av dokumentinformationstjänsten finns i tjänstdokumentationen.

Loggning

Det här biblioteket använder standardloggningsbiblioteket för loggning.

Grundläggande information om HTTP-sessioner (URL:er, rubriker osv.) loggas på INFO nivå.

Detaljerad DEBUG nivåloggning, inklusive begärande-/svarskroppar och oredigerade rubriker, kan aktiveras på klienten eller per åtgärd med nyckelordsargumentet logging_enable .

Se fullständig SDK-loggningsdokumentation med exempel här.

Valfri konfiguration

Valfria nyckelordsargument kan skickas in på klient- och åtgärdsnivå. Referensdokumentationen för azure-core beskriver tillgängliga konfigurationer för återförsök, loggning, transportprotokoll med mera.

Nästa steg

Mer exempelkod

Se README-exempel för flera kodfragment som illustrerar vanliga mönster som används i Formigenkänning Python API.

Ytterligare dokumentation

Mer omfattande dokumentation om Azure AI-dokumentinformation finns i dokumentationen om dokumentinformation om docs.microsoft.com.

Bidra

Det här projektet välkomnar bidrag och förslag. Merparten av bidragen kräver att du godkänner ett licensavtal för bidrag, där du deklarerar att du har behörighet att bevilja oss rättigheten att använda ditt bidrag, och att du dessutom uttryckligen gör så. Mer information finns i cla.microsoft.com.

När du skickar en pull-förfrågan avgör en CLA-robot automatiskt om du måste tillhandahålla ett licensavtal för bidrag med lämplig PR (t.ex. etikett eller kommentar). Följ bara robotens anvisningar. Du behöver bara göra detta en gång för alla repor som använder vårt licensavtal för bidrag.

Det här projektet använder sig av Microsofts uppförandekod för öppen källkod. Mer information finns i Vanliga frågor och svar om uppförandekoden eller kontakta opencode@microsoft.com med ytterligare frågor eller kommentarer.