DocumentModelAdministrationClient class

Erstellen einer DocumentModelAdministrationClient-Instanz von einem Ressourcenendpunkt und einem statischen API-Schlüssel (KeyCredential),

Beispiel:

import { AzureKeyCredential, DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new AzureKeyCredential("<API key>");
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

new DocumentModelAdministrationClient(endpoint: string, credential: KeyCredential, options?: DocumentModelAdministrationClientOptions)

Parameter

Erstellen Sie eine DocumentModelAdministrationClient-Instanz aus einem Ressourcenendpunkt und einer Azure Identity TokenCredential.

Weitere Informationen zur Authentifizierung mit Azure Active Directory finden Sie im @azure/identity-Paket.

Beispiel:

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

new DocumentModelAdministrationClient(endpoint: string, credential: TokenCredential, options?: DocumentModelAdministrationClientOptions)

Parameter

Erstellen Sie einen neuen Dokumentklassifizierer mit der angegebenen Klassifizierungs-ID und Dokumenttypen.

Die Klassifizierer-ID muss zwischen Klassifizierern innerhalb der Ressource eindeutig sein.

Die Dokumenttypen werden als Objekt angegeben, das den Namen des Dokumenttyps dem Schulungsdatensatz für diesen Dokumenttyp zuordnet. Zwei Eingabemethoden für Schulungsdaten werden unterstützt:

• azureBlobSource, der einen Klassifizierer mit den Daten im angegebenen Azure Blob Storage-Container trainiert.
• azureBlobFileListSource, das mit azureBlobSource vergleichbar ist, ermöglicht jedoch eine genauere Kontrolle über die Dateien, die im Schulungsdatensatz enthalten sind, mithilfe einer JSONL-formatierten Dateiliste.

Der Formularerkennungsdienst liest den Schulungsdatensatz aus einem Azure Storage-Container, der als URL zum Container mit einem SAS-Token angegeben wird, mit dem das Dienst-Back-End mit dem Container kommunizieren kann. Mindestens sind die Berechtigungen "Lesen" und "Liste" erforderlich. Darüber hinaus müssen die Daten im angegebenen Container gemäß einer bestimmten Konvention organisiert werden, die in dokumentation des Diensts zum Erstellen benutzerdefinierter Dokumentklassifiziererdokumentiert ist.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

const newClassifiedId = "aNewClassifier";
const containerUrl1 = "<training data container SAS URL 1>";
const containerUrl2 = "<training data container SAS URL 2>";

const poller = await client.beginBuildDocumentClassifier(
  newClassifiedId,
  {
    // The document types. Each entry in this object should map a document type name to a
    // `ClassifierDocumentTypeDetails` object
    formX: {
      azureBlobSource: {
        containerUrl: containerUrl1,
      },
    },
    formY: {
      azureBlobFileListSource: {
        containerUrl: containerUrl2,
        fileList: "path/to/fileList.jsonl",
      },
    },
  },
  {
    // Optionally, a text description may be attached to the classifier
    description: "This is an example classifier!",
  },
);

// Classifier building, like model creation operations, returns a poller that eventually produces a
// DocumentClassifierDetails object
const classifierDetails = await poller.pollUntilDone();

const {
  classifierId, // identical to the classifierId given when creating the classifier
  description, // identical to the description given when creating the classifier (if any)
  createdOn, // the Date (timestamp) that the classifier was created
  docTypes, // information about the document types in the classifier and their details
} = classifierDetails;

function beginBuildDocumentClassifier(classifierId: string, docTypeSources: DocumentClassifierDocumentTypeSources, options?: BeginBuildDocumentClassifierOptions): Promise<DocumentClassifierPoller>

Parameter

Gibt zurück

ein lang ausgeführter Vorgang (Poller), der schließlich die erstellten Klassifizierungsdetails oder einen Fehler erzeugt.

Erstellen Sie ein neues Modell mit einer bestimmten ID aus einer Modellinhaltsquelle.

Die Modell-ID kann aus einem beliebigen Text bestehen, solange sie nicht mit "prebuilt-" beginnt (da diese Modelle auf vordefinierte Formularerkennungsmodelle verweisen, die für alle Ressourcen gemeinsam sind), und solange sie nicht bereits innerhalb der Ressource vorhanden sind.

Die Inhaltsquelle beschreibt den Mechanismus, den der Dienst zum Lesen der Eingabeschulungsdaten verwendet. Weitere Informationen finden Sie im <xref:DocumentModelContentSource> Typ.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

const containerSasUrl = "<SAS url to the blob container storing training documents>";

// You must provide the model ID. It can be any text that does not start with "prebuilt-".
// For example, you could provide a randomly generated GUID using the "uuid" package.
// The second parameter is the SAS-encoded URL to an Azure Storage container with the training documents.
// The third parameter is the build mode: one of "template" (the only mode prior to 4.0.0-beta.3) or "neural".
// See https://aka.ms/azsdk/formrecognizer/buildmode for more information about build modes.
const poller = await client.beginBuildDocumentModel(
  "<model ID>",
  { azureBlobSource: { containerUrl: containerSasUrl } },
  "template",
  {
    // The model description is optional and can be any text.
    description: "This is my new model!",
    onProgress: ({ status }) => {
      console.log(`operation status: ${status}`);
    },
  },
);
const model = await poller.pollUntilDone();

console.log(`Model ID: ${model.modelId}`);
console.log(`Description: ${model.description}`);
console.log(`Created: ${model.createdOn}`);

// A model may contain several document types, which describe the possible object structures of fields extracted using
// this model

console.log("Document Types:");
for (const [docType, { description, fieldSchema: schema }] of Object.entries(
  model.docTypes ?? {},
)) {
  console.log(`- Name: "${docType}"`);
  console.log(`  Description: "${description}"`);

  // For simplicity, this example will only show top-level field names
  console.log("  Fields:");

  for (const [fieldName, fieldSchema] of Object.entries(schema)) {
    console.log(`  - "${fieldName}" (${fieldSchema.type})`);
    console.log(`    ${fieldSchema.description ?? "<no description>"}`);
  }
}

function beginBuildDocumentModel(modelId: string, contentSource: DocumentModelSource, buildMode: DocumentModelBuildMode, options?: BeginBuildDocumentModelOptions): Promise<DocumentModelPoller>

Parameter

Gibt zurück

ein lang ausgeführter Vorgang (Poller), der schließlich die erstellten Modellinformationen oder einen Fehler erzeugt

Erstellen Sie ein neues Modell mit einer bestimmten ID aus einer Reihe von Eingabedokumenten und beschrifteten Feldern.

Die Modell-ID kann aus einem beliebigen Text bestehen, solange sie nicht mit "prebuilt-" beginnt (da diese Modelle auf vordefinierte Formularerkennungsmodelle verweisen, die für alle Ressourcen gemeinsam sind), und solange sie nicht bereits innerhalb der Ressource vorhanden sind.

Der Formularerkennungsdienst liest den Schulungsdatensatz aus einem Azure Storage-Container, der als URL zum Container mit einem SAS-Token angegeben wird, mit dem das Dienst-Back-End mit dem Container kommunizieren kann. Mindestens sind die Berechtigungen "Lesen" und "Liste" erforderlich. Darüber hinaus müssen die Daten im angegebenen Container nach einer bestimmten Konvention organisiert werden, die in dokumentation des Diensts zum Erstellen von benutzerdefinierten Modellendokumentiert ist.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

const containerSasUrl = "<SAS url to the blob container storing training documents>";

// You must provide the model ID. It can be any text that does not start with "prebuilt-".
// For example, you could provide a randomly generated GUID using the "uuid" package.
// The second parameter is the SAS-encoded URL to an Azure Storage container with the training documents.
// The third parameter is the build mode: one of "template" (the only mode prior to 4.0.0-beta.3) or "neural".
// See https://aka.ms/azsdk/formrecognizer/buildmode for more information about build modes.
const poller = await client.beginBuildDocumentModel("<model ID>", containerSasUrl, "template", {
  // The model description is optional and can be any text.
  description: "This is my new model!",
  onProgress: ({ status }) => {
    console.log(`operation status: ${status}`);
  },
});
const model = await poller.pollUntilDone();

console.log(`Model ID: ${model.modelId}`);
console.log(`Description: ${model.description}`);
console.log(`Created: ${model.createdOn}`);

// A model may contain several document types, which describe the possible object structures of fields extracted using
// this model

console.log("Document Types:");
for (const [docType, { description, fieldSchema: schema }] of Object.entries(
  model.docTypes ?? {},
)) {
  console.log(`- Name: "${docType}"`);
  console.log(`  Description: "${description}"`);

  // For simplicity, this example will only show top-level field names
  console.log("  Fields:");

  for (const [fieldName, fieldSchema] of Object.entries(schema)) {
    console.log(`  - "${fieldName}" (${fieldSchema.type})`);
    console.log(`    ${fieldSchema.description ?? "<no description>"}`);
  }
}

function beginBuildDocumentModel(modelId: string, containerUrl: string, buildMode: DocumentModelBuildMode, options?: BeginBuildDocumentModelOptions): Promise<DocumentModelPoller>

Parameter

Gibt zurück

ein lang ausgeführter Vorgang (Poller), der schließlich die erstellten Modellinformationen oder einen Fehler erzeugt

Erstellt ein einzelnes zusammengesetztes Modell aus mehreren vorhandenen Untermodellen.

Das resultierende zusammengesetzte Modell kombiniert die Dokumenttypen seiner Komponentenmodelle und fügt einen Klassifizierungsschritt in die Extraktionspipeline ein, um zu bestimmen, welche Komponentenuntermodelle für die angegebene Eingabe am besten geeignet sind.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

const composeModelId = "aNewComposedModel";
const subModelIds = ["documentType1Model", "documentType2Model", "documentType3Model"];

// The resulting composed model can classify and extract data from documents
// conforming to any of the above document types
const poller = await client.beginComposeDocumentModel(composeModelId, subModelIds, {
  description: "This is a composed model that can handle several document types.",
});
// Model composition, like all other model creation operations, returns a poller that eventually produces a
// ModelDetails object
const modelDetails = await poller.pollUntilDone();

const {
  modelId, // identical to the modelId given when creating the model
  description, // identical to the description given when creating the model
  createdOn, // the Date (timestamp) that the model was created
  docTypes, // information about the document types of the composed submodels
} = modelDetails;

function beginComposeDocumentModel(modelId: string, componentModelIds: Iterable<string>, options?: BeginComposeDocumentModelOptions): Promise<DocumentModelPoller>

Parameter

Gibt zurück

ein lang ausgeführter Vorgang (Poller), der schließlich die erstellten Modellinformationen oder einen Fehler erzeugt

Kopiert ein Modell mit der angegebenen ID in die Ressourcen- und Modell-ID, die durch eine bestimmte Kopierautorisierung codiert wurde.

Siehe CopyAuthorization und getCopyAuthorization.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient, AzureKeyCredential } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

// We create the copy authorization using a client authenticated with the destination resource. Note that these two
// resources can be the same (you can copy a model to a new ID in the same resource).
const copyAuthorization = await client.getCopyAuthorization("<destination model ID>");

// Finally, use the _source_ client to copy the model and await the copy operation
// We need a client for the source model's resource
const sourceEndpoint = "https://<source resource name>.cognitiveservices.azure.com";
const sourceCredential = new AzureKeyCredential("<source api key>");
const sourceClient = new DocumentModelAdministrationClient(sourceEndpoint, sourceCredential);
const poller = await sourceClient.beginCopyModelTo("<source model ID>", copyAuthorization);

// Model copying, like all other model creation operations, returns a poller that eventually produces a ModelDetails
// object
const modelDetails = await poller.pollUntilDone();

const {
  modelId, // identical to the modelId given when creating the copy authorization
  description, // identical to the description given when creating the copy authorization
  createdOn, // the Date (timestamp) that the model was created
  docTypes, // information about the document types of the model (identical to the original, source model)
} = modelDetails;

function beginCopyModelTo(sourceModelId: string, authorization: CopyAuthorization, options?: BeginCopyModelOptions): Promise<DocumentModelPoller>

Parameter

Gibt zurück

ein lang ausgeführter Vorgang (Poller), der schließlich die kopierten Modellinformationen oder einen Fehler erzeugt

Löscht einen Klassifizierer mit der angegebenen ID aus der Ressource des Clients, sofern vorhanden. Dieser Vorgang kann nicht wiederhergestellt werden.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

await client.deleteDocumentClassifier("<classifier ID to delete>");

function deleteDocumentClassifier(classifierId: string, options?: OperationOptions): Promise<void>

Parameter

Gibt zurück

Löscht ein Modell mit der angegebenen ID aus der Ressource des Clients, sofern vorhanden. Dieser Vorgang kann nicht wiederhergestellt werden.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

await client.deleteDocumentModel("<model ID to delete>");

function deleteDocumentModel(modelId: string, options?: DeleteDocumentModelOptions): Promise<void>

Parameter

Gibt zurück

Erstellt eine Autorisierung zum Kopieren eines Modells in die Ressource, die mit der beginCopyModelTo-Methode verwendet wird.

Der CopyAuthorization gewährt einer weiteren kognitiven Dienstressource das Recht, ein Modell in der Ressource dieses Clients mit der Modell-ID und optionaler Beschreibung zu erstellen, die in der Autorisierung codiert sind.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

// The copyAuthorization data structure stored below grants any cognitive services resource the right to copy a
// model into the client's resource with the given destination model ID.
const copyAuthorization = await client.getCopyAuthorization("<destination model ID>");

function getCopyAuthorization(destinationModelId: string, options?: GetCopyAuthorizationOptions): Promise<CopyAuthorization>

Parameter

Gibt zurück

eine Kopierautorisierung, die die angegebene modelId und optionale Beschreibung codiert.

Ruft Informationen zu einem Klassifizierer (DocumentClassifierDetails) nach ID ab.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

const foundClassifier = "<classifier ID>";

const {
  classifierId, // identical to the ID given when calling `getDocumentClassifier`
  description, // a textual description of the classifier, if provided during classifier creation
  createdOn, // the Date (timestamp) that the classifier was created
  // information about the document types in the classifier and their corresponding traning data
  docTypes,
} = await client.getDocumentClassifier(foundClassifier);

// The `docTypes` property is a map of document type names to information about the training data
// for that document type.
for (const [docTypeName, classifierDocTypeDetails] of Object.entries(docTypes)) {
  console.log(`- '${docTypeName}': `, classifierDocTypeDetails);
}

function getDocumentClassifier(classifierId: string, options?: OperationOptions): Promise<DocumentClassifierDetails>

Parameter

Gibt zurück

Informationen zum Klassifizierer mit der angegebenen ID

Ruft Informationen zu einem Modell (DocumentModelDetails) nach ID ab.

Diese Methode kann Informationen zu benutzerdefinierten und vordefinierten Modellen abrufen.

In früheren Versionen der Formularerkennungs-REST-API und des SDK konnte die getModel-Methode jedes Modell zurückgeben, auch eines, das aufgrund von Fehlern nicht erstellt werden konnte. In den neuen Dienstversionen erstellen getDocumentModel und listDocumentModelsnur erfolgreich erstellte Modelle (d. h. Modelle, die "einsatzbereit" sind). Fehlgeschlagene Modelle werden jetzt über die "Operations"-APIs abgerufen, siehe getOperation und listOperations.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

// The ID of the prebuilt business card model
const prebuiltModelId = "prebuilt-businessCard";

const {
  modelId, // identical to the modelId given when calling `getDocumentModel`
  description, // a textual description of the model, if provided during model creation
  createdOn, // the Date (timestamp) that the model was created
  // information about the document types in the model and their field schemas
  docTypes: {
    // the document type of the prebuilt business card model
    "prebuilt:businesscard": {
      // an optional, textual description of this document type
      description: businessCardDescription,
      // the schema of the fields in this document type, see the FieldSchema type
      fieldSchema,
      // the service's confidences in the fields (an object with field names as properties and numeric confidence
      // values)
      fieldConfidence,
    },
  },
} = await client.getDocumentModel(prebuiltModelId);

function getDocumentModel(modelId: string, options?: GetModelOptions): Promise<DocumentModelDetails>

Parameter

Gibt zurück

Informationen zum Modell mit der angegebenen ID

Ruft Informationen zu einem Vorgang (OperationDetails) anhand seiner ID ab.

Vorgänge stellen Nichtanalyseaufgaben dar, z. B. Erstellen, Verfassen oder Kopieren eines Modells.

function getOperation(operationId: string, options?: GetOperationOptions): Promise<OperationDetails>

Parameter

Gibt zurück

Informationen zum Vorgang mit der angegebenen ID

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

// The ID of the operation, which should be a GUID
const findOperationId = "<operation GUID>";

const {
  operationId, // identical to the operationId given when calling `getOperation`
  kind, // the operation kind, one of "documentModelBuild", "documentModelCompose", or "documentModelCopyTo"
  status, // the status of the operation, one of "notStarted", "running", "failed", "succeeded", or "canceled"
  percentCompleted, // a number between 0 and 100 representing the progress of the operation
  createdOn, // a Date object that reflects the time when the operation was started
  lastUpdatedOn, // a Date object that reflects the time when the operation state was last modified
} = await client.getOperation(findOperationId);

Rufen Sie grundlegende Informationen zur Ressource dieses Clients ab.

Beispiel

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

const {
  // Information about the custom models in the current resource
  customDocumentModels: {
    // The number of custom models in the current resource
    count,
    // The maximum number of models that the current resource can support
    limit,
  },
} = await client.getResourceDetails();

function getResourceDetails(options?: GetResourceDetailsOptions): Promise<ResourceDetails>

Parameter

Gibt zurück

Grundlegende Informationen zur Ressource dieses Clients

Details zu Klassifizierern in der Ressource auflisten. Dieser Vorgang unterstützt paging.

Beispiele

Asynchrone Iteration

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

for await (const details of client.listDocumentClassifiers()) {
  const {
    classifierId, // The classifier's unique ID
    description, // a textual description of the classifier, if provided during creation
    docTypes, // information about the document types in the classifier and their corresponding traning data
  } = details;
}

// The listDocumentClassifiers method is paged, and you can iterate by page using the `byPage` method.
const pages = client.listDocumentClassifiers().byPage();

for await (const page of pages) {
  // Each page is an array of classifiers and can be iterated synchronously
  for (const details of page) {
    const {
      classifierId, // The classifier's unique ID
      description, // a textual description of the classifier, if provided during creation
      docTypes, // information about the document types in the classifier and their corresponding traning data
    } = details;
  }
}

function listDocumentClassifiers(options?: ListModelsOptions): PagedAsyncIterableIterator<DocumentClassifierDetails, DocumentClassifierDetails[], PageSettings>

Parameter

Gibt zurück

eine asynchrone Iterable von Klassifizierungsdetails, die Paging unterstützen

Listet Zusammenfassungen von Modellen in der Ressource auf. Benutzerdefinierte und vorgefertigte Modelle sind enthalten. Dieser Vorgang unterstützt paging.

Die Modellzusammenfassung (DocumentModelSummary) enthält nur die grundlegenden Informationen zum Modell und enthält keine Informationen zu den Dokumenttypen im Modell (z. B. Feldschemas und Konfidenzwerte).

Um auf die vollständigen Informationen zum Modell zuzugreifen, verwenden Sie getDocumentModel.

In früheren Versionen der Formularerkennungs-REST-API und des SDK würde die listModels-Methode alle Modelle zurückgeben, auch diejenigen, die aufgrund von Fehlern nicht erstellt werden konnten. In den neuen Dienstversionen erstellen listDocumentModels und getDocumentModelnur erfolgreich erstellte Modelle (d. h. Modelle, die "einsatzbereit" sind). Fehlgeschlagene Modelle werden jetzt über die "Operations"-APIs abgerufen, siehe getOperation und listOperations.

Beispiele

Asynchrone Iteration

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

// Iterate over all models in the current resource
for await (const summary of client.listDocumentModels()) {
  const {
    modelId, // The model's unique ID
    description, // a textual description of the model, if provided during model creation
  } = summary;

  // You can get the full model info using `getDocumentModel`
  const model = await client.getDocumentModel(modelId);
}

// The listDocumentModels method is paged, and you can iterate by page using the `byPage` method.
const pages = client.listDocumentModels().byPage();

for await (const page of pages) {
  // Each page is an array of models and can be iterated synchronously
  for (const summary of page) {
    const {
      modelId, // The model's unique ID
      description, // a textual description of the model, if provided during model creation
    } = summary;

    // You can get the full model info using `getDocumentModel`
    const model = await client.getDocumentModel(modelId);
  }
}

function listDocumentModels(options?: ListModelsOptions): PagedAsyncIterableIterator<DocumentModelSummary, DocumentModelSummary[], PageSettings>

Parameter

Gibt zurück

eine asynchrone Iterable von Modellzusammenfassungen, die paging unterstützen

Listenmodellerstellungsvorgänge in der Ressource. Dadurch werden alle Vorgänge erstellt, einschließlich Vorgängen, die nicht erfolgreich Modelle erstellt haben. Dieser Vorgang unterstützt paging.

Beispiele

Asynchrone Iteration

import { DefaultAzureCredential } from "@azure/identity";
import { DocumentModelAdministrationClient } from "@azure/ai-form-recognizer";

const credential = new DefaultAzureCredential();
const client = new DocumentModelAdministrationClient(
  "https://<resource name>.cognitiveservices.azure.com",
  credential,
);

for await (const operation of client.listOperations()) {
  const {
    operationId, // the operation's GUID
    status, // the operation status, one of "notStarted", "running", "succeeded", "failed", or "canceled"
    percentCompleted, // the progress of the operation, from 0 to 100
  } = operation;
}

// The listOperations method is paged, and you can iterate by page using the `byPage` method.
const pages = client.listOperations().byPage();

for await (const page of pages) {
  // Each page is an array of operation info objects and can be iterated synchronously
  for (const operation of page) {
    const {
      operationId, // the operation's GUID
      status, // the operation status, one of "notStarted", "running", "succeeded", "failed", or "canceled"
      percentCompleted, // the progress of the operation, from 0 to 100
    } = operation;
  }
}

function listOperations(options?: ListOperationsOptions): PagedAsyncIterableIterator<OperationSummary, OperationSummary[], PageSettings>

Parameter

Gibt zurück

asynchrones Iterable of operation information objects that supports paging