Split out analyze methods for supervised and unsupervised models

sdk/formrecognizer/Azure.AI.FormRecognizer/src/CustomFormClient.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -117,35 +119,72 @@ public virtual async Task<Operation<CustomLabeledModel>> StartTrainingWithLabels
         #endregion Training
 
         #region Analyze
-        public virtual Operation<ExtractedForm> StartExtractForm(string modelId, Stream stream, FormContentType contentType, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+
+        #region Unsupervised
+        public virtual Operation<IReadOnlyList<ExtractedPage>> StartExtractPages(string modelId, Stream stream, FormContentType contentType, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        {
+            // TODO: automate content-type detection
+            // https://github.com/Azure/azure-sdk-for-net/issues/10329
+            ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = _operations.AnalyzeWithCustomModel(new Guid(modelId), includeTextDetails: includeRawPageExtractions, stream, contentType, cancellationToken);
+            return new ExtractPagesOperation(_operations, modelId, response.Headers.OperationLocation);
+        }
+
+        public virtual Operation<IReadOnlyList<ExtractedPage>> StartExtractPages(string modelId, Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        {
+            SourcePath_internal sourcePath = new SourcePath_internal() { Source = uri.ToString() };
+            ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = _operations.RestClient.AnalyzeWithCustomModel(new Guid(modelId), includeTextDetails: includeRawPageExtractions, sourcePath, cancellationToken);
+            return new ExtractPagesOperation(_operations, modelId, response.Headers.OperationLocation);
+        }
+
+        public virtual async Task<Operation<IReadOnlyList<ExtractedPage>>> StartExtractPagesAsync(string modelId, Stream stream, FormContentType contentType, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        {
+            // TODO: automate content-type detection
+            // https://github.com/Azure/azure-sdk-for-net/issues/10329
+            ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = await _operations.AnalyzeWithCustomModelAsync(new Guid(modelId), includeTextDetails: includeRawPageExtractions, stream, contentType, cancellationToken).ConfigureAwait(false);
+            return new ExtractPagesOperation(_operations, modelId, response.Headers.OperationLocation);
+        }
+
+        public virtual async Task<Operation<IReadOnlyList<ExtractedPage>>> StartExtractPagesAsync(string modelId, Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        {
+            SourcePath_internal sourcePath = new SourcePath_internal() { Source = uri.ToString() };
+            ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = await _operations.RestClient.AnalyzeWithCustomModelAsync(new Guid(modelId), includeTextDetails: includeRawPageExtractions, sourcePath, cancellationToken).ConfigureAwait(false);
+            return new ExtractPagesOperation(_operations, modelId, response.Headers.OperationLocation);
+        }
+        #endregion
+
+        #region Supervised
+        public virtual Operation<IReadOnlyList<ExtractedLabeledForm>> StartExtractLabeledForms(string modelId, Stream stream, FormContentType contentType, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
         {
             // TODO: automate content-type detection
             // https://github.com/Azure/azure-sdk-for-net/issues/10329
             ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = _operations.AnalyzeWithCustomModel(new Guid(modelId), includeTextDetails: includeRawPageExtractions, stream, contentType, cancellationToken);
-            return new ExtractFormOperation(_operations, modelId, response.Headers.OperationLocation);
+            return new ExtractLabeledFormOperation(_operations, modelId, response.Headers.OperationLocation);
         }
 
-        public virtual Operation<ExtractedForm> StartExtractForm(string modelId, Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        public virtual Operation<IReadOnlyList<ExtractedLabeledForm>> StartExtractLabeledForms(string modelId, Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
         {
             SourcePath_internal sourcePath = new SourcePath_internal() { Source = uri.ToString() };
             ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = _operations.RestClient.AnalyzeWithCustomModel(new Guid(modelId), includeTextDetails: includeRawPageExtractions, sourcePath, cancellationToken);
-            return new ExtractFormOperation(_operations, modelId, response.Headers.OperationLocation);
+            return new ExtractLabeledFormOperation(_operations, modelId, response.Headers.OperationLocation);
         }
 
-        public virtual async Task<Operation<ExtractedForm>> StartExtractFormAsync(string modelId, Stream stream, FormContentType contentType, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        public virtual async Task<Operation<IReadOnlyList<ExtractedLabeledForm>>> StartExtractLabeledFormsAsync(string modelId, Stream stream, FormContentType contentType, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
         {
             // TODO: automate content-type detection
             // https://github.com/Azure/azure-sdk-for-net/issues/10329
             ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = await _operations.AnalyzeWithCustomModelAsync(new Guid(modelId), includeTextDetails: includeRawPageExtractions, stream, contentType, cancellationToken).ConfigureAwait(false);
-            return new ExtractFormOperation(_operations, modelId, response.Headers.OperationLocation);
+            return new ExtractLabeledFormOperation(_operations, modelId, response.Headers.OperationLocation);
         }
 
-        public virtual async Task<Operation<ExtractedForm>> StartExtractFormAsync(string modelId, Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
+        public virtual async Task<Operation<IReadOnlyList<ExtractedLabeledForm>>> StartExtractLabeledFormsAsync(string modelId, Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default)
         {
             SourcePath_internal sourcePath = new SourcePath_internal() { Source = uri.ToString() };
             ResponseWithHeaders<AnalyzeWithCustomModelHeaders> response = await _operations.RestClient.AnalyzeWithCustomModelAsync(new Guid(modelId), includeTextDetails: includeRawPageExtractions, sourcePath, cancellationToken).ConfigureAwait(false);
-            return new ExtractFormOperation(_operations, modelId, response.Headers.OperationLocation);
+            return new ExtractLabeledFormOperation(_operations, modelId, response.Headers.OperationLocation);
         }
+        #endregion
+
+        // TODO: Add methods for labeled models
 
         #endregion Analyze
 

sdk/formrecognizer/Azure.AI.FormRecognizer/src/ExtractLabeledFormOperation.cs

@@ -0,0 +1,107 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.Core;
+using Azure.Core.Pipeline;
+
+namespace Azure.AI.FormRecognizer.Models
+{
+    /// <summary>
+    /// </summary>
+    internal class ExtractLabeledFormOperation : Operation<IReadOnlyList<ExtractedLabeledForm>>
+    {
+        private Response _response;
+        private IReadOnlyList<ExtractedLabeledForm> _value;
+        private bool _hasCompleted;
+
+        private readonly string _modelId;
+        private readonly ServiceClient _operations;
+
+        public override string Id { get; }
+
+        public override IReadOnlyList<ExtractedLabeledForm> Value => OperationHelpers.GetValue(ref _value);
+
+        public override bool HasCompleted => _hasCompleted;
+
+        public override bool HasValue => _value != null;
+
+        /// <inheritdoc/>
+        public override Response GetRawResponse() => _response;
+
+        /// <inheritdoc/>
+        public override ValueTask<Response<IReadOnlyList<ExtractedLabeledForm>>> WaitForCompletionAsync(CancellationToken cancellationToken = default) =>
+            this.DefaultWaitForCompletionAsync(cancellationToken);
+
+        /// <inheritdoc/>
+        public override ValueTask<Response<IReadOnlyList<ExtractedLabeledForm>>> WaitForCompletionAsync(TimeSpan pollingInterval, CancellationToken cancellationToken = default) =>
+            this.DefaultWaitForCompletionAsync(pollingInterval, cancellationToken);
+
+        /// <summary>
+        /// </summary>
+        /// <param name="operations"></param>
+        /// <param name="modelId"></param>
+        /// <param name="operationLocation"></param>
+        internal ExtractLabeledFormOperation(ServiceClient operations, string modelId, string operationLocation)
+        {
+            _operations = operations;
+            _modelId = modelId;
+
+            // TODO: Add validation here
+            // https://github.com/Azure/azure-sdk-for-net/issues/10385
+            Id = operationLocation.Split('/').Last();
+        }
+
+        /// <inheritdoc/>
+        public override Response UpdateStatus(CancellationToken cancellationToken = default) =>
+            UpdateStatusAsync(false, cancellationToken).EnsureCompleted();
+
+        /// <inheritdoc/>
+        public override async ValueTask<Response> UpdateStatusAsync(CancellationToken cancellationToken = default) =>
+            await UpdateStatusAsync(true, cancellationToken).ConfigureAwait(false);
+
+        private async Task<Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
+        {
+            if (!_hasCompleted)
+            {
+                Response<AnalyzeOperationResult_internal> update = async
+                    ? await _operations.GetAnalyzeFormResultAsync(new Guid(_modelId), new Guid(Id), cancellationToken).ConfigureAwait(false)
+                    : _operations.GetAnalyzeFormResult(new Guid(_modelId), new Guid(Id), cancellationToken);
+
+                // TODO: Handle correctly according to returned status code
+                // https://github.com/Azure/azure-sdk-for-net/issues/10386
+                // TODO: Add reasonable null checks.
+
+                if (update.Value.Status == OperationStatus.Succeeded || update.Value.Status == OperationStatus.Failed)
+                {
+                    _hasCompleted = true;
+
+                    // TODO: Consider what we'll do when there are multiple DocumentResults
+                    // https://github.com/Azure/azure-sdk-for-net/issues/10387
+                    // Supervised
+                    _value = ConvertToExtractedLabeledForms(update.Value.AnalyzeResult.DocumentResults, update.Value.AnalyzeResult.PageResults, update.Value.AnalyzeResult.ReadResults);
+                }
+
+                _response = update.GetRawResponse();
+            }
+
+            return GetRawResponse();
+        }
+
+        private static IReadOnlyList<ExtractedLabeledForm> ConvertToExtractedLabeledForms(IList<DocumentResult_internal> documentResults, IList<PageResult_internal> pageResults, IList<ReadResult_internal> readResults)
+        {
+            List<ExtractedLabeledForm> forms = new List<ExtractedLabeledForm>();
+            for (int i = 0; i < documentResults.Count; i++)
+            {
+                // TODO: How do we know what pages in pageResults map to the pages in documents?
+                // Think about this in the morning.
+                forms.Add(new ExtractedLabeledForm(documentResults[i], pageResults[i], readResults[i]));
+            }
+            return forms;
+        }
+    }
+}

sdk/formrecognizer/Azure.AI.FormRecognizer/src/ExtractFormOperation.cs → sdk/formrecognizer/Azure.AI.FormRecognizer/src/ExtractPagesOperation.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -12,18 +13,18 @@ namespace Azure.AI.FormRecognizer.Models
 {
     /// <summary>
     /// </summary>
-    internal class ExtractFormOperation : Operation<ExtractedForm>
+    internal class ExtractPagesOperation : Operation<IReadOnlyList<ExtractedPage>>
     {
         private Response _response;
-        private ExtractedForm _value;
+        private IReadOnlyList<ExtractedPage> _value;
         private bool _hasCompleted;
 
         private readonly string _modelId;
         private readonly ServiceClient _operations;
 
         public override string Id { get; }
 
-        public override ExtractedForm Value => OperationHelpers.GetValue(ref _value);
+        public override IReadOnlyList<ExtractedPage> Value => OperationHelpers.GetValue(ref _value);
 
         public override bool HasCompleted => _hasCompleted;
 
@@ -33,19 +34,19 @@ internal class ExtractFormOperation : Operation<ExtractedForm>
         public override Response GetRawResponse() => _response;
 
         /// <inheritdoc/>
-        public override ValueTask<Response<ExtractedForm>> WaitForCompletionAsync(CancellationToken cancellationToken = default) =>
+        public override ValueTask<Response<IReadOnlyList<ExtractedPage>>> WaitForCompletionAsync(CancellationToken cancellationToken = default) =>
             this.DefaultWaitForCompletionAsync(cancellationToken);
 
         /// <inheritdoc/>
-        public override ValueTask<Response<ExtractedForm>> WaitForCompletionAsync(TimeSpan pollingInterval, CancellationToken cancellationToken = default) =>
+        public override ValueTask<Response<IReadOnlyList<ExtractedPage>>> WaitForCompletionAsync(TimeSpan pollingInterval, CancellationToken cancellationToken = default) =>
             this.DefaultWaitForCompletionAsync(pollingInterval, cancellationToken);
 
         /// <summary>
         /// </summary>
         /// <param name="operations"></param>
         /// <param name="modelId"></param>
         /// <param name="operationLocation"></param>
-        internal ExtractFormOperation(ServiceClient operations, string modelId, string operationLocation)
+        internal ExtractPagesOperation(ServiceClient operations, string modelId, string operationLocation)
         {
             _operations = operations;
             _modelId = modelId;
@@ -78,27 +79,23 @@ private async Task<Response> UpdateStatusAsync(bool async, CancellationToken can
                 if (update.Value.Status == OperationStatus.Succeeded || update.Value.Status == OperationStatus.Failed)
                 {
                     _hasCompleted = true;
-
-                    // TODO: Move this logic into ExtractedForm?  It's a bit convoluted right now.
-                    // Determine if the model was supervised or unsupervised
-                    if (update.Value.AnalyzeResult.DocumentResults?.Count == 0)
-                    {
-                        // Unsupervised
-                        _value = new ExtractedForm(update.Value.AnalyzeResult.PageResults, update.Value.AnalyzeResult.ReadResults);
-                    }
-                    else
-                    {
-                        // TODO: Consider what we'll do when there are multiple DocumentResults
-                        // https://github.com/Azure/azure-sdk-for-net/issues/10387
-                        // Supervised
-                        _value = new ExtractedForm(update.Value.AnalyzeResult.DocumentResults.First(), update.Value.AnalyzeResult.PageResults, update.Value.AnalyzeResult.ReadResults);
-                    }
+                    _value = ConvertToExtractedPages(update.Value.AnalyzeResult.PageResults, update.Value.AnalyzeResult.ReadResults);
                 }
 
                 _response = update.GetRawResponse();
             }
 
             return GetRawResponse();
         }
+
+        private static IReadOnlyList<ExtractedPage> ConvertToExtractedPages(IList<PageResult_internal> pageResults, IList<ReadResult_internal> readResults)
+        {
+            List<ExtractedPage> pages = new List<ExtractedPage>();
+            for (int i = 0; i < pageResults.Count; i++)
+            {
+                pages.Add(new ExtractedPage(pageResults[i], readResults[i]));
+            }
+            return pages;
+        }
     }
 }