/// <summary>
/// Recognizes pages from one or more forms, using a model trained with custom forms.
/// </summary>
/// <param name="modelId">The ID of the model to use for recognizing form values.</param>
/// <param name="formUri">The absolute URI of the remote file to recognize elements from.</param>
/// <param name="recognizeCustomFormsOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeCustomFormsOperation"/> to wait on this long-running operation. Its <see cref="RecognizeCustomFormsOperation.Value"/> upon successful
/// completion will contain recognized pages from the input document.</returns>
public virtual async Task <RecognizeCustomFormsOperation> StartRecognizeCustomFormsFromUriAsync(string modelId, Uri formUri, RecognizeCustomFormsOptions recognizeCustomFormsOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(modelId, nameof(modelId));
Argument.AssertNotNull(formUri, nameof(formUri));
recognizeCustomFormsOptions ??= new RecognizeCustomFormsOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeCustomFormsFromUri)}");
scope.Start();
try
{
Guid guid = ClientCommon.ValidateModelId(modelId, nameof(modelId));
SourcePath sourcePath = new SourcePath()
{
Source = formUri.AbsoluteUri
};
Response response = await ServiceClient.AnalyzeWithCustomModelAsync(guid, includeTextDetails : recognizeCustomFormsOptions.IncludeFieldElements, sourcePath, cancellationToken).ConfigureAwait(false);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeCustomFormsOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Recognizes values from one or more receipts.
/// </summary>
/// <param name="receiptUri">The absolute URI of the remote file to recognize values from.</param>
/// <param name="recognizeReceiptsOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeReceiptsOperation"/> to wait on this long-running operation. Its <see cref="RecognizeReceiptsOperation.Value"/> upon successful
/// completion will contain the extracted receipt.</returns>
public virtual RecognizeReceiptsOperation StartRecognizeReceiptsFromUri(Uri receiptUri, RecognizeReceiptsOptions recognizeReceiptsOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(receiptUri, nameof(receiptUri));
recognizeReceiptsOptions ??= new RecognizeReceiptsOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeReceiptsFromUri)}");
scope.Start();
try
{
SourcePath sourcePath = new SourcePath()
{
Source = receiptUri.AbsoluteUri
};
Response response = ServiceClient.AnalyzeReceiptAsync(includeTextDetails: recognizeReceiptsOptions.IncludeFieldElements, sourcePath, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeReceiptsOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Recognizes pages from one or more forms, using a model trained with custom forms.
/// </summary>
/// <param name="modelId">The ID of the model to use for recognizing form values.</param>
/// <param name="form">The stream containing one or more forms to recognize elements from.</param>
/// <param name="recognizeCustomFormsOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeCustomFormsOperation"/> to wait on this long-running operation. Its <see cref="RecognizeCustomFormsOperation.Value"/> upon successful
/// completion will contain recognized pages from the input document.</returns>
public virtual RecognizeCustomFormsOperation StartRecognizeCustomForms(string modelId, Stream form, RecognizeCustomFormsOptions recognizeCustomFormsOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(modelId, nameof(modelId));
Argument.AssertNotNull(form, nameof(form));
recognizeCustomFormsOptions ??= new RecognizeCustomFormsOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeCustomForms)}");
scope.Start();
try
{
Guid guid = ClientCommon.ValidateModelId(modelId, nameof(modelId));
FormContentType contentType = recognizeCustomFormsOptions.ContentType ?? DetectContentType(form, nameof(form));
Response response = ServiceClient.AnalyzeWithCustomModel(guid, contentType, form, includeTextDetails: recognizeCustomFormsOptions.IncludeFieldElements, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeCustomFormsOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Recognizes layout elements from one or more passed-in forms.
/// </summary>
/// <param name="formUri">The absolute URI of the remote file to recognize elements from.</param>
/// <param name="recognizeContentOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeContentOperation"/> to wait on this long-running operation. Its <see cref="RecognizeContentOperation.Value"/> upon successful
/// completion will contain layout elements extracted from the form.</returns>
public virtual async Task <RecognizeContentOperation> StartRecognizeContentFromUriAsync(Uri formUri, RecognizeContentOptions recognizeContentOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(formUri, nameof(formUri));
recognizeContentOptions ??= new RecognizeContentOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeContentFromUri)}");
scope.Start();
try
{
SourcePath sourcePath = new SourcePath()
{
Source = formUri.AbsoluteUri
};
Response response = await ServiceClient.AnalyzeLayoutAsyncAsync(sourcePath, cancellationToken).ConfigureAwait(false);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeContentOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Recognizes values from one or more receipts.
/// </summary>
/// <param name="receipt">The stream containing the one or more receipts to recognize values from.</param>
/// <param name="recognizeReceiptsOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeReceiptsOperation"/> to wait on this long-running operation. Its <see cref="RecognizeReceiptsOperation.Value"/> upon successful
/// completion will contain the extracted receipt.</returns>
public virtual async Task <RecognizeReceiptsOperation> StartRecognizeReceiptsAsync(Stream receipt, RecognizeReceiptsOptions recognizeReceiptsOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(receipt, nameof(receipt));
recognizeReceiptsOptions ??= new RecognizeReceiptsOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeReceipts)}");
scope.Start();
try
{
FormContentType contentType = recognizeReceiptsOptions.ContentType ?? DetectContentType(receipt, nameof(receipt));
Response response = await ServiceClient.AnalyzeReceiptAsyncAsync(contentType, receipt, includeTextDetails : recognizeReceiptsOptions.IncludeFieldElements, cancellationToken).ConfigureAwait(false);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeReceiptsOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Recognizes values from one or more business cards.
/// <para>See <a href="https://aka.ms/formrecognizer/businesscardfields"/> for a list of available fields on a business card.</para>
/// </summary>
/// <param name="businessCardUri">The absolute URI of the remote file to recognize values from.</param>
/// <param name="recognizeBusinessCardsOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeBusinessCardsOperation"/> to wait on this long-running operation. Its <see cref="RecognizeBusinessCardsOperation.Value"/> upon successful
/// completion will contain the extracted business cards.</returns>
public virtual async Task <RecognizeBusinessCardsOperation> StartRecognizeBusinessCardsFromUriAsync(Uri businessCardUri, RecognizeBusinessCardsOptions recognizeBusinessCardsOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(businessCardUri, nameof(businessCardUri));
recognizeBusinessCardsOptions ??= new RecognizeBusinessCardsOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeBusinessCardsFromUri)}");
scope.Start();
try
{
SourcePath sourcePath = new SourcePath()
{
Source = businessCardUri.AbsoluteUri
};
Response response = await ServiceClient.AnalyzeBusinessCardAsyncAsync(includeTextDetails : recognizeBusinessCardsOptions.IncludeFieldElements, locale : recognizeBusinessCardsOptions.Locale, fileStream : sourcePath, cancellationToken).ConfigureAwait(false);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeBusinessCardsOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual RecognizeContentOperation StartRecognizeContentFromUri(Uri formUrl, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(formUrl, nameof(formUrl));
SourcePath_internal sourcePath = new SourcePath_internal(formUrl.AbsoluteUri);
Response response = ServiceClient.AnalyzeLayoutAsync(sourcePath, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeContentOperation(ServiceClient, Diagnostics, location));
}
public virtual RecognizeReceiptsOperation StartRecognizeReceiptsFromUri(Uri receiptUrl, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(receiptUrl, nameof(receiptUrl));
recognizeOptions ??= new RecognizeOptions();
SourcePath_internal sourcePath = new SourcePath_internal(receiptUrl.AbsoluteUri);
Response response = ServiceClient.AnalyzeReceiptAsync(includeTextDetails: recognizeOptions.IncludeTextContent, sourcePath, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeReceiptsOperation(ServiceClient, Diagnostics, location));
}
public virtual RecognizeReceiptsOperation StartRecognizeReceipts(Stream receipt, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(receipt, nameof(receipt));
recognizeOptions ??= new RecognizeOptions();
FormContentType contentType = recognizeOptions.ContentType ?? DetectContentType(receipt, nameof(receipt));
Response response = ServiceClient.AnalyzeReceiptAsync(contentType, receipt, includeTextDetails: recognizeOptions.IncludeTextContent, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeReceiptsOperation(ServiceClient, Diagnostics, location));
}
public virtual RecognizeContentOperation StartRecognizeContent(Stream form, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(form, nameof(form));
recognizeOptions ??= new RecognizeOptions();
FormContentType contentType = recognizeOptions.ContentType ?? DetectContentType(form, nameof(form));
Response response = ServiceClient.AnalyzeLayoutAsync(contentType, form, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeContentOperation(ServiceClient, Diagnostics, location));
}
public virtual async Task <RecognizeReceiptsOperation> StartRecognizeReceiptsFromUriAsync(Uri receiptUri, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(receiptUri, nameof(receiptUri));
recognizeOptions ??= new RecognizeOptions();
SourcePath_internal sourcePath = new SourcePath_internal(receiptUri.AbsoluteUri);
Response response = await ServiceClient.AnalyzeReceiptAsyncAsync(includeTextDetails : recognizeOptions.IncludeFieldElements, sourcePath, cancellationToken).ConfigureAwait(false);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeReceiptsOperation(ServiceClient, Diagnostics, location));
}
public virtual RecognizeCustomFormsOperation StartRecognizeCustomFormsFromUri(string modelId, Uri formFileUri, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(modelId, nameof(modelId));
Argument.AssertNotNull(formFileUri, nameof(formFileUri));
Guid guid = ClientCommon.ValidateModelId(modelId, nameof(modelId));
recognizeOptions ??= new RecognizeOptions();
SourcePath_internal sourcePath = new SourcePath_internal(formFileUri.AbsoluteUri);
Response response = ServiceClient.AnalyzeWithCustomModel(guid, includeTextDetails: recognizeOptions.IncludeTextContent, sourcePath, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeCustomFormsOperation(ServiceClient, Diagnostics, location));
}
public virtual RecognizeCustomFormsOperation StartRecognizeCustomForms(string modelId, Stream formFileStream, RecognizeOptions recognizeOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(modelId, nameof(modelId));
Argument.AssertNotNull(formFileStream, nameof(formFileStream));
Guid guid = ClientCommon.ValidateModelId(modelId, nameof(modelId));
recognizeOptions ??= new RecognizeOptions();
FormContentType contentType = recognizeOptions.ContentType ?? DetectContentType(formFileStream, nameof(formFileStream));
Response response = ServiceClient.AnalyzeWithCustomModel(guid, contentType, formFileStream, includeTextDetails: recognizeOptions.IncludeTextContent, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeCustomFormsOperation(ServiceClient, Diagnostics, location));
}
/// <summary>
/// Recognizes layout elements from one or more passed-in forms.
/// </summary>
/// <param name="form">The stream containing one or more forms to recognize elements from.</param>
/// <param name="recognizeContentOptions">A set of options available for configuring the recognize request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>A <see cref="RecognizeContentOperation"/> to wait on this long-running operation. Its <see cref="RecognizeContentOperation.Value"/> upon successful
/// completion will contain layout elements extracted from the form.</returns>
public virtual RecognizeContentOperation StartRecognizeContent(Stream form, RecognizeContentOptions recognizeContentOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(form, nameof(form));
recognizeContentOptions ??= new RecognizeContentOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormRecognizerClient)}.{nameof(StartRecognizeContent)}");
scope.Start();
try
{
FormContentType contentType = recognizeContentOptions.ContentType ?? DetectContentType(form, nameof(form));
Response response = ServiceClient.AnalyzeLayoutAsync(contentType, form, cancellationToken);
string location = ClientCommon.GetResponseHeader(response.Headers, Constants.OperationLocationHeader);
return(new RecognizeContentOperation(ServiceClient, Diagnostics, location));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}