public async Task TrainingOps(bool labeled, bool useTokenCredential)
{
var client = CreateFormTrainingClient(useTokenCredential);
var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl);
TrainingOperation operation = await client.StartTrainingAsync(trainingFilesUri, labeled);
await operation.WaitForCompletionAsync(PollingInterval);
Assert.IsTrue(operation.HasValue);
CustomFormModel trainedModel = operation.Value;
CustomFormModel resultModel = await client.GetCustomModelAsync(trainedModel.ModelId);
Assert.AreEqual(trainedModel.ModelId, resultModel.ModelId);
Assert.AreEqual(trainedModel.Properties.IsComposedModel, resultModel.Properties.IsComposedModel);
Assert.AreEqual(trainedModel.TrainingStartedOn, resultModel.TrainingStartedOn);
Assert.AreEqual(trainedModel.TrainingCompletedOn, resultModel.TrainingCompletedOn);
Assert.AreEqual(CustomFormModelStatus.Ready, resultModel.Status);
Assert.AreEqual(trainedModel.Status, resultModel.Status);
Assert.AreEqual(trainedModel.Errors.Count, resultModel.Errors.Count);
for (int i = 0; i < resultModel.TrainingDocuments.Count; i++)
{
var tm = trainedModel.TrainingDocuments[i];
var rm = resultModel.TrainingDocuments[i];
Assert.AreEqual(tm.Name, rm.Name);
Assert.AreEqual(tm.ModelId, rm.ModelId);
Assert.AreEqual(tm.PageCount, rm.PageCount);
Assert.AreEqual(TrainingStatus.Succeeded, rm.Status);
Assert.AreEqual(tm.Status, rm.Status);
Assert.AreEqual(tm.Errors.Count, rm.Errors.Count);
}
for (int i = 0; i < resultModel.Submodels.Count; i++)
{
Assert.AreEqual(trainedModel.Submodels[i].FormType, resultModel.Submodels[i].FormType);
Assert.AreEqual(trainedModel.Submodels[i].ModelId, resultModel.Submodels[i].ModelId);
foreach (var fields in resultModel.Submodels[i].Fields)
{
Assert.AreEqual(trainedModel.Submodels[i].Fields[fields.Key].Name, fields.Value.Name);
if (labeled)
{
Assert.AreEqual(trainedModel.Submodels[i].Fields[fields.Key].Accuracy, fields.Value.Accuracy);
}
else
{
Assert.AreEqual(trainedModel.Submodels[i].Fields[fields.Key].Label, fields.Value.Label);
}
}
}
CustomFormModelInfo modelInfo = client.GetCustomModelsAsync().ToEnumerableAsync().Result.FirstOrDefault();
Assert.IsNotNull(modelInfo.ModelId);
Assert.IsNotNull(modelInfo.TrainingStartedOn);
Assert.IsNotNull(modelInfo.TrainingCompletedOn);
Assert.IsNotNull(modelInfo.Status);
Assert.IsNotNull(modelInfo.Properties);
AccountProperties accountP = await client.GetAccountPropertiesAsync();
Assert.IsNotNull(accountP.CustomModelCount);
Assert.IsNotNull(accountP.CustomModelLimit);
await client.DeleteModelAsync(trainedModel.ModelId);
RequestFailedException ex = Assert.ThrowsAsync <RequestFailedException>(() => client.GetCustomModelAsync(trainedModel.ModelId));
Assert.AreEqual("1022", ex.ErrorCode);
}
/// <summary>
/// Run samples for Order By queries.
/// </summary>
/// <returns>a Task object.</returns>
private async Task <RunSummary> ExecuteAsync(BenchmarkConfig config, string accountKey)
{
using (CosmosClient cosmosClient = config.CreateCosmosClient(accountKey))
{
if (config.CleanupOnStart)
{
Microsoft.Azure.Cosmos.Database database = cosmosClient.GetDatabase(config.Database);
await database.DeleteStreamAsync();
}
ContainerResponse containerResponse = await Program.CreatePartitionedContainerAsync(config, cosmosClient);
Container container = containerResponse;
int?currentContainerThroughput = await container.ReadThroughputAsync();
Console.WriteLine($"Using container {config.Container} with {currentContainerThroughput} RU/s");
int taskCount = config.GetTaskCount(currentContainerThroughput.Value);
Console.WriteLine("Starting Inserts with {0} tasks", taskCount);
Console.WriteLine();
string partitionKeyPath = containerResponse.Resource.PartitionKeyPath;
int opsPerTask = config.ItemCount / taskCount;
// TBD: 2 clients SxS some overhead
RunSummary runSummary;
using (DocumentClient documentClient = config.CreateDocumentClient(accountKey))
{
Func <IBenchmarkOperation> benchmarkOperationFactory = this.GetBenchmarkFactory(
config,
partitionKeyPath,
cosmosClient,
documentClient);
if (config.DisableCoreSdkLogging)
{
// Do it after client initialization (HACK)
Program.ClearCoreSdkListeners();
}
IExecutionStrategy execution = IExecutionStrategy.StartNew(config, benchmarkOperationFactory);
runSummary = await execution.ExecuteAsync(taskCount, opsPerTask, config.TraceFailures, 0.01);
}
if (config.CleanupOnFinish)
{
Console.WriteLine($"Deleting Database {config.Database}");
Microsoft.Azure.Cosmos.Database database = cosmosClient.GetDatabase(config.Database);
await database.DeleteStreamAsync();
}
runSummary.WorkloadType = config.WorkloadType;
runSummary.id = $"{DateTime.UtcNow.ToString("yyyy-MM-dd:HH-mm")}-{config.CommitId}";
runSummary.Commit = config.CommitId;
runSummary.CommitDate = config.CommitDate;
runSummary.CommitTime = config.CommitTime;
runSummary.Date = DateTime.UtcNow.ToString("yyyy-MM-dd");
runSummary.Time = DateTime.UtcNow.ToString("HH-mm");
runSummary.BranchName = config.BranchName;
runSummary.TotalOps = config.ItemCount;
runSummary.Concurrency = taskCount;
runSummary.Database = config.Database;
runSummary.Container = config.Container;
runSummary.AccountName = config.EndPoint;
runSummary.pk = config.ResultsPartitionKeyValue;
string consistencyLevel = config.ConsistencyLevel;
if (string.IsNullOrWhiteSpace(consistencyLevel))
{
AccountProperties accountProperties = await cosmosClient.ReadAccountAsync();
consistencyLevel = accountProperties.Consistency.DefaultConsistencyLevel.ToString();
}
runSummary.ConsistencyLevel = consistencyLevel;
if (config.PublishResults)
{
Container resultsContainer = cosmosClient.GetContainer(config.Database, config.ResultsContainer);
await resultsContainer.CreateItemAsync(runSummary, new PartitionKey(runSummary.pk));
}
return(runSummary);
}
}
/// <summary>
/// Executing benchmarks for V2/V3 cosmosdb SDK.
/// </summary>
/// <returns>a Task object.</returns>
private async Task <RunSummary> ExecuteAsync(BenchmarkConfig config)
{
// V3 SDK client initialization
using (CosmosClient cosmosClient = config.CreateCosmosClient(config.Key))
{
Microsoft.Azure.Cosmos.Database database = cosmosClient.GetDatabase(config.Database);
if (config.CleanupOnStart)
{
await database.DeleteStreamAsync();
}
ContainerResponse containerResponse = await Program.CreatePartitionedContainerAsync(config, cosmosClient);
Container container = containerResponse;
int?currentContainerThroughput = await container.ReadThroughputAsync();
if (!currentContainerThroughput.HasValue)
{
// Container throughput is not configured. It is shared database throughput
ThroughputResponse throughputResponse = await database.ReadThroughputAsync(requestOptions : null);
throw new InvalidOperationException($"Using database {config.Database} with {throughputResponse.Resource.Throughput} RU/s. " +
$"Container {config.Container} must have a configured throughput.");
}
Console.WriteLine($"Using container {config.Container} with {currentContainerThroughput} RU/s");
int taskCount = config.GetTaskCount(currentContainerThroughput.Value);
Console.WriteLine("Starting Inserts with {0} tasks", taskCount);
Console.WriteLine();
string partitionKeyPath = containerResponse.Resource.PartitionKeyPath;
int opsPerTask = config.ItemCount / taskCount;
// TBD: 2 clients SxS some overhead
RunSummary runSummary;
// V2 SDK client initialization
using (Microsoft.Azure.Documents.Client.DocumentClient documentClient = config.CreateDocumentClient(config.Key))
{
Func <IBenchmarkOperation> benchmarkOperationFactory = this.GetBenchmarkFactory(
config,
partitionKeyPath,
cosmosClient,
documentClient);
if (config.DisableCoreSdkLogging)
{
// Do it after client initialization (HACK)
Program.ClearCoreSdkListeners();
}
IExecutionStrategy execution = IExecutionStrategy.StartNew(benchmarkOperationFactory);
runSummary = await execution.ExecuteAsync(config, taskCount, opsPerTask, 0.01);
}
if (config.CleanupOnFinish)
{
Console.WriteLine($"Deleting Database {config.Database}");
await database.DeleteStreamAsync();
}
string consistencyLevel = config.ConsistencyLevel;
if (string.IsNullOrWhiteSpace(consistencyLevel))
{
AccountProperties accountProperties = await cosmosClient.ReadAccountAsync();
consistencyLevel = accountProperties.Consistency.DefaultConsistencyLevel.ToString();
}
runSummary.ConsistencyLevel = consistencyLevel;
if (config.PublishResults)
{
runSummary.Diagnostics = CosmosDiagnosticsLogger.GetDiagnostics();
await this.PublishResults(
config,
runSummary,
cosmosClient);
}
return(runSummary);
}
}
public async Task ManageCustomModels()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
#region Snippet:FormRecognizerSampleManageCustomModels
FormTrainingClient client = new FormTrainingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
// Check number of models in the FormRecognizer account, and the maximum number of models that can be stored.
AccountProperties accountProperties = client.GetAccountProperties();
Console.WriteLine($"Account has {accountProperties.CustomModelCount} models.");
Console.WriteLine($"It can have at most {accountProperties.CustomModelLimit} models.");
// List the first ten or fewer models currently stored in the account.
Pageable <CustomFormModelInfo> models = client.GetCustomModels();
foreach (CustomFormModelInfo modelInfo in models.Take(10))
{
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {modelInfo.ModelId}");
Console.WriteLine($" Model name: {modelInfo.ModelName}");
Console.WriteLine($" Is composed model: {modelInfo.Properties.IsComposedModel}");
Console.WriteLine($" Model Status: {modelInfo.Status}");
Console.WriteLine($" Training model started on: {modelInfo.TrainingStartedOn}");
Console.WriteLine($" Training model completed on: {modelInfo.TrainingCompletedOn}");
}
// Create a new model to store in the account
#if SNIPPET
Uri trainingFileUri = < trainingFileUri >;
#else
Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrlV2);
#endif
TrainingOperation operation = client.StartTraining(trainingFileUri, useTrainingLabels: false, "My new model");
Response <CustomFormModel> operationResponse = await operation.WaitForCompletionAsync();
CustomFormModel model = operationResponse.Value;
// Get the model that was just created
CustomFormModel modelCopy = client.GetCustomModel(model.ModelId);
Console.WriteLine($"Custom Model with Id {modelCopy.ModelId} and name {modelCopy.ModelName} recognizes the following form types:");
foreach (CustomFormSubmodel submodel in modelCopy.Submodels)
{
Console.WriteLine($"Submodel Form Type: {submodel.FormType}");
foreach (CustomFormModelField field in submodel.Fields.Values)
{
Console.Write($" FieldName: {field.Name}");
if (field.Label != null)
{
Console.Write($", FieldLabel: {field.Label}");
}
Console.WriteLine("");
}
}
// Delete the model from the account.
client.DeleteModel(model.ModelId);
#endregion
}
public async Task ManageModelsAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
#region Snippet:FormRecognizerSampleManageModelsAsync
var client = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
// Check number of custom models in the FormRecognizer account, and the maximum number of models that can be stored.
AccountProperties accountProperties = await client.GetAccountPropertiesAsync();
Console.WriteLine($"Account has {accountProperties.DocumentModelCount} models.");
Console.WriteLine($"It can have at most {accountProperties.DocumentModelLimit} models.");
// List the first ten or fewer models currently stored in the account.
AsyncPageable <DocumentModelInfo> models = client.GetModelsAsync();
int count = 0;
await foreach (DocumentModelInfo modelInfo in models)
{
Console.WriteLine($"Custom Model Info:");
Console.WriteLine($" Model Id: {modelInfo.ModelId}");
if (string.IsNullOrEmpty(modelInfo.Description))
{
Console.WriteLine($" Model description: {modelInfo.Description}");
}
Console.WriteLine($" Created on: {modelInfo.CreatedOn}");
if (++count == 10)
{
break;
}
}
// Create a new model to store in the account
#if SNIPPET
Uri trainingFileUri = new Uri("<trainingFileUri>");
#else
Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrl);
#endif
BuildModelOperation operation = await client.StartBuildModelAsync(trainingFileUri, DocumentBuildMode.Template);
Response <DocumentModel> operationResponse = await operation.WaitForCompletionAsync();
DocumentModel model = operationResponse.Value;
// Get the model that was just created
DocumentModel newCreatedModel = await client.GetModelAsync(model.ModelId);
Console.WriteLine($"Custom Model with Id {newCreatedModel.ModelId} has the following information:");
Console.WriteLine($" Model Id: {newCreatedModel.ModelId}");
if (string.IsNullOrEmpty(newCreatedModel.Description))
{
Console.WriteLine($" Model description: {newCreatedModel.Description}");
}
Console.WriteLine($" Created on: {newCreatedModel.CreatedOn}");
// Delete the model from the account.
await client.DeleteModelAsync(newCreatedModel.ModelId);
#endregion
}
/// <summary>
/// The Get Account Create Operation Status operation returns the
/// status of the account creation operation. After calling an
/// asynchronous operation, you can call this method to determine
/// whether the operation has succeeded, failed, or is still in
/// progress.
/// </summary>
/// <param name='operationStatusLink'>
/// Required. Location value returned by the BeginCreating operation.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
/// <returns>
/// Values returned by the Create operation.
/// </returns>
public async Task <BatchAccountCreateResponse> GetAccountCreateOperationStatusAsync(string operationStatusLink, CancellationToken cancellationToken)
{
// Validate
if (operationStatusLink == null)
{
throw new ArgumentNullException("operationStatusLink");
}
// Tracing
bool shouldTrace = TracingAdapter.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = TracingAdapter.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("operationStatusLink", operationStatusLink);
TracingAdapter.Enter(invocationId, this, "GetAccountCreateOperationStatusAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + operationStatusLink;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = null;
try
{
httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Get;
httpRequest.RequestUri = new Uri(url);
// Set Headers
httpRequest.Headers.Add("x-ms-version", "2015-07-01");
// Set Credentials
cancellationToken.ThrowIfCancellationRequested();
await this.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
// Send Request
HttpResponseMessage httpResponse = null;
try
{
if (shouldTrace)
{
TracingAdapter.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await this.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
TracingAdapter.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Accepted)
{
cancellationToken.ThrowIfCancellationRequested();
CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
if (shouldTrace)
{
TracingAdapter.Error(invocationId, ex);
}
throw ex;
}
// Create Result
BatchAccountCreateResponse result = null;
// Deserialize Response
if (statusCode == HttpStatusCode.OK || statusCode == HttpStatusCode.Accepted)
{
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
result = new BatchAccountCreateResponse();
JToken responseDoc = null;
if (string.IsNullOrEmpty(responseContent) == false)
{
responseDoc = JToken.Parse(responseContent);
}
if (responseDoc != null && responseDoc.Type != JTokenType.Null)
{
AccountResource resourceInstance = new AccountResource();
result.Resource = resourceInstance;
JToken idValue = responseDoc["id"];
if (idValue != null && idValue.Type != JTokenType.Null)
{
string idInstance = ((string)idValue);
resourceInstance.Id = idInstance;
}
JToken typeValue = responseDoc["type"];
if (typeValue != null && typeValue.Type != JTokenType.Null)
{
string typeInstance = ((string)typeValue);
resourceInstance.Type = typeInstance;
}
JToken nameValue = responseDoc["name"];
if (nameValue != null && nameValue.Type != JTokenType.Null)
{
string nameInstance = ((string)nameValue);
resourceInstance.Name = nameInstance;
}
JToken locationValue = responseDoc["location"];
if (locationValue != null && locationValue.Type != JTokenType.Null)
{
string locationInstance = ((string)locationValue);
resourceInstance.Location = locationInstance;
}
JToken tagsSequenceElement = ((JToken)responseDoc["tags"]);
if (tagsSequenceElement != null && tagsSequenceElement.Type != JTokenType.Null)
{
foreach (JProperty property in tagsSequenceElement)
{
string tagsKey = ((string)property.Name);
string tagsValue = ((string)property.Value);
resourceInstance.Tags.Add(tagsKey, tagsValue);
}
}
JToken propertiesValue = responseDoc["properties"];
if (propertiesValue != null && propertiesValue.Type != JTokenType.Null)
{
AccountProperties propertiesInstance = new AccountProperties();
resourceInstance.Properties = propertiesInstance;
JToken accountEndpointValue = propertiesValue["accountEndpoint"];
if (accountEndpointValue != null && accountEndpointValue.Type != JTokenType.Null)
{
string accountEndpointInstance = ((string)accountEndpointValue);
propertiesInstance.AccountEndpoint = accountEndpointInstance;
}
JToken provisioningStateValue = propertiesValue["provisioningState"];
if (provisioningStateValue != null && provisioningStateValue.Type != JTokenType.Null)
{
AccountProvisioningState provisioningStateInstance = ((AccountProvisioningState)Enum.Parse(typeof(AccountProvisioningState), ((string)provisioningStateValue), true));
propertiesInstance.ProvisioningState = provisioningStateInstance;
}
}
BatchManagementError errorInstance = new BatchManagementError();
result.Error = errorInstance;
JToken codeValue = responseDoc["code"];
if (codeValue != null && codeValue.Type != JTokenType.Null)
{
string codeInstance = ((string)codeValue);
errorInstance.Code = codeInstance;
}
JToken messageValue = responseDoc["message"];
if (messageValue != null && messageValue.Type != JTokenType.Null)
{
string messageInstance = ((string)messageValue);
errorInstance.Message = messageInstance;
}
JToken targetValue = responseDoc["target"];
if (targetValue != null && targetValue.Type != JTokenType.Null)
{
string targetInstance = ((string)targetValue);
errorInstance.Target = targetInstance;
}
}
}
result.StatusCode = statusCode;
if (httpResponse.Headers.Contains("x-ms-request-id"))
{
result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (result.Resource != null && result.Resource.Properties != null && result.Resource.Properties.ProvisioningState == AccountProvisioningState.Succeeded)
{
result.Status = OperationStatus.Succeeded;
}
if (shouldTrace)
{
TracingAdapter.Exit(invocationId, result);
}
return(result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
}
finally
{
if (httpRequest != null)
{
httpRequest.Dispose();
}
}
}
public override void ExecuteCmdlet()
{
if (ServiceType != StorageServiceType.Table)
{
ServiceProperties currentServiceProperties = Channel.GetStorageServiceProperties(ServiceType, GetRequestOptions(ServiceType), OperationContext);
// Premium Account not support classic metrics and logging
if ((MetricsType == ServiceMetricsType.Hour && currentServiceProperties.HourMetrics == null) ||
(MetricsType == ServiceMetricsType.Minute && currentServiceProperties.MinuteMetrics == null))
{
AccountProperties accountProperties = Channel.GetAccountProperties();
if (accountProperties.SkuName.Contains("Premium"))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "This Storage account doesn't support Classic Metrics, since it’s a Premium Storage account: {0}", Channel.StorageContext.StorageAccountName));
}
}
ServiceProperties serviceProperties = new ServiceProperties();
serviceProperties.Clean();
bool isHourMetrics = false;
switch (MetricsType)
{
case ServiceMetricsType.Hour:
serviceProperties.HourMetrics = currentServiceProperties.HourMetrics;
UpdateServiceProperties(serviceProperties.HourMetrics);
isHourMetrics = true;
break;
case ServiceMetricsType.Minute:
serviceProperties.MinuteMetrics = currentServiceProperties.MinuteMetrics;
UpdateServiceProperties(serviceProperties.MinuteMetrics);
isHourMetrics = false;
break;
}
Channel.SetStorageServiceProperties(ServiceType, serviceProperties,
GetRequestOptions(ServiceType), OperationContext);
if (PassThru)
{
if (isHourMetrics)
{
WriteObject(serviceProperties.HourMetrics);
}
else
{
WriteObject(serviceProperties.MinuteMetrics);
}
}
}
else //Table use old XSCL
{
StorageTableManagement tableChannel = new StorageTableManagement(Channel.StorageContext);
XTable.ServiceProperties currentServiceProperties = tableChannel.GetStorageTableServiceProperties(GetTableRequestOptions(), TableOperationContext);
// Premium Account not support classic metrics and logging
if ((MetricsType == ServiceMetricsType.Hour && currentServiceProperties.HourMetrics == null) ||
(MetricsType == ServiceMetricsType.Minute && currentServiceProperties.MinuteMetrics == null))
{
AccountProperties accountProperties = Channel.GetAccountProperties();
if (accountProperties.SkuName.Contains("Premium"))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "This Storage account doesn't support Classic Metrics, since it’s a Premium Storage account: {0}", Channel.StorageContext.StorageAccountName));
}
}
XTable.ServiceProperties serviceProperties = new XTable.ServiceProperties();
serviceProperties.Clean();
bool isHourMetrics = false;
switch (MetricsType)
{
case ServiceMetricsType.Hour:
serviceProperties.HourMetrics = currentServiceProperties.HourMetrics;
UpdateServiceProperties(serviceProperties.HourMetrics);
isHourMetrics = true;
break;
case ServiceMetricsType.Minute:
serviceProperties.MinuteMetrics = currentServiceProperties.MinuteMetrics;
UpdateServiceProperties(serviceProperties.MinuteMetrics);
isHourMetrics = false;
break;
}
tableChannel.SetStorageTableServiceProperties(serviceProperties,
GetTableRequestOptions(), TableOperationContext);
if (PassThru)
{
if (isHourMetrics)
{
WriteObject(serviceProperties.HourMetrics);
}
else
{
WriteObject(serviceProperties.MinuteMetrics);
}
}
}
}
public async Task TrainingOps(bool labeled)
{
var client = CreateInstrumentedFormTrainingClient();
var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl);
TrainingOperation operation;
// TODO: sanitize body and enable body recording here.
using (Recording.DisableRequestBodyRecording())
{
operation = await client.StartTrainingAsync(trainingFilesUri, labeled);
}
await operation.WaitForCompletionAsync();
Assert.IsTrue(operation.HasValue);
CustomFormModel trainedModel = operation.Value;
CustomFormModel resultModel = await client.GetCustomModelAsync(trainedModel.ModelId);
Assert.AreEqual(trainedModel.ModelId, resultModel.ModelId);
Assert.AreEqual(trainedModel.CreatedOn, resultModel.CreatedOn);
Assert.AreEqual(trainedModel.LastModified, resultModel.LastModified);
Assert.AreEqual(CustomFormModelStatus.Ready, resultModel.Status);
Assert.AreEqual(trainedModel.Status, resultModel.Status);
Assert.AreEqual(trainedModel.Errors.Count, resultModel.Errors.Count);
for (int i = 0; i < resultModel.TrainingDocuments.Count; i++)
{
var tm = trainedModel.TrainingDocuments[i];
var rm = resultModel.TrainingDocuments[i];
Assert.AreEqual(tm.DocumentName, rm.DocumentName);
Assert.AreEqual(tm.PageCount, rm.PageCount);
Assert.AreEqual(TrainingStatus.Succeeded, rm.Status);
Assert.AreEqual(tm.Status, rm.Status);
Assert.AreEqual(tm.Errors.Count, rm.Errors.Count);
}
for (int i = 0; i < resultModel.Models.Count; i++)
{
Assert.AreEqual(trainedModel.Models[i].FormType, resultModel.Models[i].FormType);
foreach (var fields in resultModel.Models[i].Fields)
{
Assert.AreEqual(trainedModel.Models[i].Fields[fields.Key].Name, fields.Value.Name);
if (labeled)
{
Assert.AreEqual(trainedModel.Models[i].Fields[fields.Key].Accuracy, fields.Value.Accuracy);
}
else
{
Assert.AreEqual(trainedModel.Models[i].Fields[fields.Key].Label, fields.Value.Label);
}
}
}
CustomFormModelInfo modelInfo = client.GetCustomModelsAsync().ToEnumerableAsync().Result.FirstOrDefault();
Assert.IsNotNull(modelInfo.ModelId);
Assert.IsNotNull(modelInfo.CreatedOn);
Assert.IsNotNull(modelInfo.LastModified);
Assert.IsNotNull(modelInfo.Status);
AccountProperties accountP = await client.GetAccountPropertiesAsync();
Assert.IsNotNull(accountP.CustomModelCount);
Assert.IsNotNull(accountP.CustomModelLimit);
await client.DeleteModelAsync(trainedModel.ModelId);
Assert.ThrowsAsync <RequestFailedException>(() => client.GetCustomModelAsync(trainedModel.ModelId));
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountPropertiesInfo" /> class.
/// </summary>
/// <param name="metaId">The account property meta id</param>
/// <param name="accountProperties">The account properties</param>
public AccountPropertiesInfo(string metaId, AccountProperties accountProperties)
{
MetaId = metaId;
AccountProperties = accountProperties;
}
public AccountViewModel(Account account, AccountProperties properties, Balances balances) : base()
{
AccountNumber = account;
_accountProperties = properties;
_balances = balances;
}
public static async Task <AccountProperties> GetDatabaseAccountFromAnyLocationsAsync(
Uri defaultEndpoint, IList <string> locations, Func <Uri, Task <AccountProperties> > getDatabaseAccountFn)
{
ExceptionDispatchInfo capturedException = null;
try
{
AccountProperties databaseAccount = await getDatabaseAccountFn(defaultEndpoint);
return(databaseAccount);
}
catch (Exception e)
{
DefaultTrace.TraceInformation("Fail to reach global gateway {0}, {1}", defaultEndpoint, e.ToString());
if (IsNonRetriableException(e))
{
DefaultTrace.TraceInformation("Exception is not retriable");
throw;
}
if (locations.Count == 0)
{
throw;
}
// Save the exception and rethrow it at the end after trying all regions
capturedException = ExceptionDispatchInfo.Capture(e);
}
for (int index = 0; index < locations.Count; index++)
{
try
{
AccountProperties databaseAccount = await getDatabaseAccountFn(LocationHelper.GetLocationEndpoint(defaultEndpoint, locations[index]));
return(databaseAccount);
}
catch (Exception e)
{
DefaultTrace.TraceInformation("Fail to reach location {0}, {1}", locations[index], e.ToString());
// if is the last region, throw exception
if (index == locations.Count - 1)
{
// The reason for rethrowing the first exception is that the locations list might contain invalid regions,
// so the last exception would be some generic exception ("The remote name could not be resolved") instead of the real exception.
// Location list containing invalid regions is quite common when SetCurrentLocation is used since it will add all Azure regions to the list
if (capturedException != null)
{
capturedException.Throw();
}
throw;
}
}
}
// we should never reach here. Make compiler happy
throw new Exception();
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Add Cognitive Services Account NetworkRules"))
{
var account = this.CognitiveServicesClient.Accounts.Get(
this.ResourceGroupName,
this.Name);
NetworkRuleSet accountACL = account.Properties.NetworkAcls;
if (accountACL == null)
{
accountACL = new NetworkRuleSet();
// Deny is the default action value from server side,
// Specifically make default action Deny in client side as server side might want this value to be always provided in future.
accountACL.DefaultAction = NetworkRuleAction.Deny;
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s, null, true);
accountACL.VirtualNetworkRules.Add(rule);
}
break;
case IpRuleStringParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (string s in IpAddressOrRange)
{
IpRule rule = new IpRule(s);
accountACL.IpRules.Add(rule);
}
break;
case NetworkRuleObjectParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
accountACL.VirtualNetworkRules.Add(rule.ToVirtualNetworkRule());
}
break;
case IpRuleObjectParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (PSIpRule rule in IpRule)
{
accountACL.IpRules.Add(rule.ToIpRule());
}
break;
}
var properties = new AccountProperties();
properties.NetworkAcls = accountACL;
this.CognitiveServicesClient.Accounts.Update(
this.ResourceGroupName,
this.Name,
new Account()
{
Properties = properties
}
);
account = this.CognitiveServicesClient.Accounts.Get(this.ResourceGroupName, this.Name);
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).IpRules);
break;
}
}
}
