public OnboardingController() { _formClient = new FormRecognizerClient(new ApiKeyServiceClientCredentials(FormRecogniserSettings.ApiKey)) { Endpoint = FormRecogniserSettings.Endpoint }; }
public MlModelService(IFormRecognizerClient formRecognizerClient, CloudBlobClient cloudBlobClient, AzureSettings azureStorageSettings, ILogger logger) { _formRecognizerClient = formRecognizerClient; _cloudBlobClient = cloudBlobClient; _azureStorageSettings = azureStorageSettings; _logger = logger; }
private string AnalyzePdfForm(IFormRecognizerClient formClient, Guid formRecognizerModelId, string filePath) { //TODO: As this is part of .NET Library, writing to console does not makes sense // Write to an Exceptions section either in jsonResult or another output and send it to caller if (string.IsNullOrEmpty(filePath)) { Console.WriteLine("\nInvalid file path."); return(null); } string jsonResult = ""; try { using (FileStream stream = new FileStream(filePath, FileMode.Open)) { //Get the result from an asynchronous call but as a synchnous way by using .Result AnalyzeResult result = formClient.AnalyzeWithCustomModelAsync(formRecognizerModelId, stream, contentType: "application/pdf").Result; jsonResult = TransformAnalyzeResult(result); } } catch (ErrorResponseException e) { Console.WriteLine("Analyze PDF form : " + e.Message); } catch (Exception ex) { Console.WriteLine("Analyze PDF form : " + ex.Message); } return(jsonResult); }
// </snippet_train> // <snippet_getkeys> // Get and display list of extracted keys for training data // provided to train the model private static async Task GetListOfExtractedKeys( IFormRecognizerClient formClient, Guid modelId) { if (modelId == Guid.Empty) { Console.WriteLine("\nInvalid model Id."); return; } try { KeysResult kr = await formClient.GetExtractedKeysAsync(modelId); var clusters = kr.Clusters; foreach (var kvp in clusters) { Console.WriteLine(" Cluster: " + kvp.Key + ""); foreach (var v in kvp.Value) { Console.WriteLine("\t" + v); } } } catch (ErrorResponseException e) { Console.WriteLine("Get list of extracted keys : " + e.Message); } }
/// <summary> /// Get Keys /// </summary> /// <remarks> /// Retrieve the keys that were /// extracted during the training of the specified model. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// Model identifier. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <KeysResult> GetExtractedKeysAsync(this IFormRecognizerClient operations, System.Guid id, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.GetExtractedKeysWithHttpMessagesAsync(id, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Get Models /// </summary> /// <remarks> /// Get information about all trained custom models /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <ModelsResult> GetCustomModelsAsync(this IFormRecognizerClient operations, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.GetCustomModelsWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// This interface is used for getting the analysis results of a 'Batch Read /// Receipt' operation. The URL to this interface should be retrieved from the /// 'Operation-Location' field returned from the 'Batch Read Receipt' /// operation. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='operationId'> /// Id of read operation returned in the response of a 'Batch Read Receipt' /// operation. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <ReadReceiptResult> GetReadReceiptResultAsync(this IFormRecognizerClient operations, string operationId, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.GetReadReceiptResultWithHttpMessagesAsync(operationId, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Train Model /// </summary> /// <remarks> /// Create and train a custom model. The train request must include a source /// parameter that is either an externally accessible Azure Storage blob /// container Uri (preferably a Shared Access Signature Uri) or valid path to a /// data folder in a locally mounted drive. When local paths are specified, /// they must follow the Linux/Unix path format and be an absolute path rooted /// to the input mount configuration /// setting value e.g., if '{Mounts:Input}' configuration setting value is /// '/input' then a valid source path would be '/input/contosodataset'. All /// data to be trained is expected to be directly under the source folder. /// Subfolders are not supported. Models are trained using documents that are /// of the following content type - 'application/pdf', 'image/jpeg' and /// 'image/png'." /// Other type of content is ignored. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='trainRequest'> /// Request object for training. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <TrainResult> TrainCustomModelAsync(this IFormRecognizerClient operations, TrainRequest trainRequest, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.TrainCustomModelWithHttpMessagesAsync(trainRequest, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
// Analyze PNG form data private static async Task AnalyzePngForm( IFormRecognizerClient formClient, Guid modelId, string pngFormFile) { if (string.IsNullOrEmpty(pngFormFile)) { Console.WriteLine("\nInvalid pngFormFile."); return; } try { using (FileStream stream = new FileStream(pngFormFile, FileMode.Open)) { AnalyzeResult result = await formClient.AnalyzeWithCustomModelAsync(modelId, stream, contentType : "image/png"); Console.WriteLine("\nExtracted data from:" + pngFormFile); DisplayAnalyzeResult(result); } } catch (ErrorResponseException e) { Console.WriteLine("Analyze PNG form " + e.Message); } catch (Exception ex) { Console.WriteLine("Analyze PNG form : " + ex.Message); } }
/// <summary> /// Batch Read Receipt operation. The response contains a field called /// 'Operation-Location', which contains the URL that you must use for your /// 'Get Read Receipt Result' operation. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='url'> /// Publicly reachable URL of an image. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <BatchReadReceiptHeaders> BatchReadReceiptAsync(this IFormRecognizerClient operations, string url, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.BatchReadReceiptWithHttpMessagesAsync(url, null, cancellationToken).ConfigureAwait(false)) { return(_result.Headers); } }
// </snippet_maintask> // <snippet_train> // Train model using training form data (pdf, jpg, png files) private static async Task <Guid> TrainModelAsync( IFormRecognizerClient formClient, string trainingDataUrl) { if (!Uri.IsWellFormedUriString(trainingDataUrl, UriKind.Absolute)) { Console.WriteLine("\nInvalid trainingDataUrl:\n{0} \n", trainingDataUrl); return(Guid.Empty); } try { TrainResult result = await formClient.TrainCustomModelAsync(new TrainRequest(trainingDataUrl)); ModelResult model = await formClient.GetCustomModelAsync(result.ModelId); DisplayModelStatus(model); return(result.ModelId); } catch (ErrorResponseException e) { Console.WriteLine("Train Model : " + e.Message); return(Guid.Empty); } }
/// <summary> /// Analyze Form /// </summary> /// <remarks> /// Extract key-value pairs from a given document. The input document must be /// of one of the supported content types - 'application/pdf', 'image/jpeg' or /// 'image/png'. A success response is returned in JSON. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// Model Identifier to analyze the document with. /// </param> /// <param name='formStream'> /// A pdf document or image (jpg,png) file to analyze. /// </param> /// <param name='keys'> /// An optional list of known keys to extract the values for. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <AnalyzeResult> AnalyzeWithCustomModelAsync(this IFormRecognizerClient operations, System.Guid id, Stream formStream, IList <string> keys = default(IList <string>), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.AnalyzeWithCustomModelWithHttpMessagesAsync(id, formStream, keys, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public DocumentAnalyzerService(IFormRecognizerClient formRecognizerClient, IMlModelService mlModelService, IFileBuilder fileBuilder, IS3FileService s3FileService, ILogger logger) { _formRecognizerClient = formRecognizerClient; _mlModelService = mlModelService; _fileBuilder = fileBuilder; _s3FileService = s3FileService; _logger = logger; }
private static async Task DeleteModel(IFormRecognizerClient formClient, Guid modelId) { try { await formClient.DeleteCustomModelAsync(modelId); } catch (ErrorResponseException e) { } }
// Delete a model private static async Task DeleteModel(IFormRecognizerClient formClient, Guid modelId) { try { Console.Write("Deleting model: {0}...", modelId.ToString()); await formClient.DeleteCustomModelAsync(modelId); Console.WriteLine("done.\n"); } catch (ErrorResponseException e) { Console.WriteLine("Delete model : " + e.Message); } }
private async Task <AnalyzeResult> AnalyzePdfForm(IFormRecognizerClient formClient, Guid modelId, Stream pdfFormFile) { try { return(await formClient.AnalyzeWithCustomModelAsync(modelId, pdfFormFile, contentType : "application/pdf")); } catch (ErrorResponseException e) { return(null); } catch (Exception ex) { return(null); } }
// Get and display list of trained the models private static async Task GetListOfModels(IFormRecognizerClient formClient) { try { ModelsResult models = await formClient.GetCustomModelsAsync(); foreach (ModelResult m in models.ModelsProperty) { Console.WriteLine(m.ModelId + " " + m.Status + " " + m.CreatedDateTime + " " + m.LastUpdatedDateTime); } Console.WriteLine(); } catch (ErrorResponseException e) { Console.WriteLine("Get list of models : " + e.Message); } }
public async Task <Guid> TrainModelAsync(IFormRecognizerClient client, string sasUrl) { ModelResult model = null; try { TrainResult result = await client.TrainCustomModelAsync(new TrainRequest(sasUrl)); model = await client.GetCustomModelAsync(result.ModelId); //Check if successful } catch (ErrorResponseException e) { LogError(e); return(Guid.Empty); } return(model.ModelId); }
public async Task <AnalyzeResult> AnalyzeForm(IFormRecognizerClient client, Guid modelId, string filePath) { AnalyzeResult result = null; //Default to PDF string contentType = "application/pdf"; switch (Path.GetExtension(filePath).ToLower().Replace(".", "")) { case "pdf": contentType = "application/pdf"; break; case "jpg": contentType = "image/jpeg"; break; case "png": contentType = "image/png"; break; default: break; } try { using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { result = await client.AnalyzeWithCustomModelAsync(modelId, stream, contentType : contentType); } } catch (Exception ex) { LogError(ex); } //used the following to serialize the result object and use for testing //var jsonVersion = Newtonsoft.Json.JsonConvert.SerializeObject(result); //System.IO.File.WriteAllText(Shared.FormRecognitionService.PATH_TO_PROJECT_ROOT + @"\Code\SampleData\SerializedObjects\AnalyzedResult.json", jsonVersion); return(result); }
private static async Task <Guid> TrainModelAsync(IFormRecognizerClient formClient, string trainingDataUrl) { if (!Uri.IsWellFormedUriString(trainingDataUrl, UriKind.Absolute)) { return(Guid.Empty); } try { var result = await formClient.TrainCustomModelAsync(new TrainRequest(trainingDataUrl)); var model = await formClient.GetCustomModelAsync(result.ModelId); return(result.ModelId); } catch (ErrorResponseException e) { return(Guid.Empty); } }
/// <summary> /// Delete Model /// </summary> /// <remarks> /// Delete model artifacts. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// The identifier of the model to delete. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task DeleteCustomModelAsync(this IFormRecognizerClient operations, System.Guid id, CancellationToken cancellationToken = default(CancellationToken)) { (await operations.DeleteCustomModelWithHttpMessagesAsync(id, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
public AnalysisService(IOptions <Settings> settings) { _settings = settings.Value; _formClient = CreateFormRecognizerClient(); }