diff --git a/build/test.ps1 b/build/test.ps1 index 7a0c737a21..2dd318fe77 100644 --- a/build/test.ps1 +++ b/build/test.ps1 @@ -41,7 +41,7 @@ function Test-Python { Write-Host "##[info]Testing Python inside $testFolder" Push-Location (Join-Path $PSScriptRoot $testFolder) python --version - pytest -v + pytest -v --log-level=Debug Pop-Location if ($LastExitCode -ne 0) { diff --git a/conda-recipes/iqsharp/build.ps1 b/conda-recipes/iqsharp/build.ps1 index f08bdeb1ee..6c76741f98 100644 --- a/conda-recipes/iqsharp/build.ps1 +++ b/conda-recipes/iqsharp/build.ps1 @@ -17,8 +17,6 @@ if ($IsWindows) { $RepoRoot = Resolve-Path (Join-Path $PSScriptRoot "../.."); $ArtifactRoot = Join-Path $RepoRoot "drops"; $SelfContainedDirectory = Join-Path $ArtifactRoot (Join-Path "selfcontained" $RuntimeID) -$NugetsDirectory = Join-Path $ArtifactRoot "nugets" -$NugetConfig = Resolve-Path (Join-Path $PSScriptRoot "NuGet.config"); $TargetDirectory = (Join-Path (Join-Path $Env:PREFIX "opt") "iqsharp"); diff --git a/conda-recipes/iqsharp/test.ps1 b/conda-recipes/iqsharp/test.ps1 index e1f14d46f0..3007f27e56 100644 --- a/conda-recipes/iqsharp/test.ps1 +++ b/conda-recipes/iqsharp/test.ps1 @@ -5,6 +5,13 @@ $failed = $false; $Env:IQSHARP_PACKAGE_SOURCE = "$Env:NUGET_OUTDIR" +# Add the prerelease NuGet feed if this isn't a release build. +if ("$Env:BUILD_RELEASETYPE" -ne "release") { + $NuGetDirectory = Resolve-Path ~ + Write-Host "## Writing prerelease NuGet config to $NuGetDirectory ##" + echo "" > $NuGetDirectory/NuGet.Config +} + # Check that iqsharp is installed as a Jupyter kernel. $kernels = jupyter kernelspec list --json | ConvertFrom-Json; if ($null -eq $kernels.kernelspecs.iqsharp) { @@ -13,7 +20,7 @@ if ($null -eq $kernels.kernelspecs.iqsharp) { jupyter kernelspec list } - +# Run the kernel unit tests. Push-Location $PSScriptRoot python test.py if ($LastExitCode -ne 0) { diff --git a/src/AzureClient/AzureClient.cs b/src/AzureClient/AzureClient.cs index 12ca9d130c..0abb670a55 100644 --- a/src/AzureClient/AzureClient.cs +++ b/src/AzureClient/AzureClient.cs @@ -73,21 +73,36 @@ public async Task ConnectAsync(IChannel channel, string storageAccountConnectionString, bool refreshCredentials = false) { - ConnectionString = storageAccountConnectionString; - var azureEnvironment = AzureEnvironment.Create(subscriptionId); - ActiveWorkspace = await azureEnvironment.GetAuthenticatedWorkspaceAsync(channel, resourceGroupName, workspaceName, refreshCredentials); - if (ActiveWorkspace == null) + IAzureWorkspace? workspace = null; + try + { + workspace = await azureEnvironment.GetAuthenticatedWorkspaceAsync(channel, resourceGroupName, workspaceName, refreshCredentials); + } + catch (Exception e) + { + channel.Stderr($"The connection to the Azure Quantum workspace could not be completed. Please check the provided parameters and try again."); + channel.Stderr($"Error details: {e.Message}"); + return AzureClientError.WorkspaceNotFound.ToExecutionResult(); + } + + if (workspace == null) { return AzureClientError.AuthenticationFailed.ToExecutionResult(); } - AvailableProviders = await ActiveWorkspace.GetProvidersAsync(); - if (AvailableProviders == null) + var providers = await workspace.GetProvidersAsync(); + if (providers == null) { return AzureClientError.WorkspaceNotFound.ToExecutionResult(); } + ActiveWorkspace = workspace; + AvailableProviders = providers; + ConnectionString = storageAccountConnectionString; + ActiveTarget = null; + MostRecentJobId = string.Empty; + channel.Stdout($"Connected to Azure Quantum workspace {ActiveWorkspace.Name}."); if (ValidExecutionTargets.Count() == 0) diff --git a/src/AzureClient/AzureClient.csproj b/src/AzureClient/AzureClient.csproj index 995ae372bb..8d7b029f32 100644 --- a/src/AzureClient/AzureClient.csproj +++ b/src/AzureClient/AzureClient.csproj @@ -13,7 +13,7 @@ - + diff --git a/src/AzureClient/Magic/ConnectMagic.cs b/src/AzureClient/Magic/ConnectMagic.cs index 867815d2cd..12114f48fb 100644 --- a/src/AzureClient/Magic/ConnectMagic.cs +++ b/src/AzureClient/Magic/ConnectMagic.cs @@ -6,6 +6,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; using Microsoft.Jupyter.Core; @@ -19,10 +20,11 @@ namespace Microsoft.Quantum.IQSharp.AzureClient public class ConnectMagic : AzureClientMagicBase { private const string ParameterNameRefresh = "refresh"; - private const string ParameterNameStorageAccountConnectionString = "storageAccountConnectionString"; - private const string ParameterNameSubscriptionId = "subscriptionId"; - private const string ParameterNameResourceGroupName = "resourceGroupName"; - private const string ParameterNameWorkspaceName = "workspaceName"; + private const string ParameterNameStorageAccountConnectionString = "storage"; + private const string ParameterNameSubscriptionId = "subscription"; + private const string ParameterNameResourceGroupName = "resourceGroup"; + private const string ParameterNameWorkspaceName = "workspace"; + private const string ParameterNameResourceId = "resourceId"; /// /// Initializes a new instance of the class. @@ -36,54 +38,73 @@ public ConnectMagic(IAzureClient azureClient) "azure.connect", new Documentation { - Summary = "Connects to an Azure workspace or displays current connection status.", + Summary = "Connects to an Azure Quantum workspace or displays current connection status.", Description = @" This magic command allows for connecting to an Azure Quantum workspace - as specified by a valid subscription ID, resource group name, workspace name, - and storage account connection string. + as specified by the resource ID of the workspace or by a combination of + subscription ID, resource group name, and workspace name. - If the connection is successful, a list of the available execution targets + If the connection is successful, a list of the available Q# execution targets in the Azure Quantum workspace will be displayed. ".Dedent(), Examples = new[] { - @" - Print information about the current connection: + $@" + Connect to an Azure Quantum workspace using its resource ID: ``` - In []: %azure.connect + In []: %azure.connect {ParameterNameResourceId}=""/subscriptions/f846b2bd-d0e2-4a1d-8141-4c6944a9d387/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Quantum/Workspaces/WORKSPACE_NAME"" Out[]: Connected to Azure Quantum workspace WORKSPACE_NAME. - + ``` ".Dedent(), $@" - Connect to an Azure Quantum workspace: + Connect to an Azure Quantum workspace using its resource ID and a storage account connection string, + which is required for workspaces that do not have a linked storage account: ``` - In []: %azure.connect {ParameterNameSubscriptionId}=SUBSCRIPTION_ID - {ParameterNameResourceGroupName}=RESOURCE_GROUP_NAME - {ParameterNameWorkspaceName}=WORKSPACE_NAME - {ParameterNameStorageAccountConnectionString}=CONNECTION_STRING + In []: %azure.connect {ParameterNameResourceId}=""/subscriptions/f846b2bd-d0e2-4a1d-8141-4c6944a9d387/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Quantum/Workspaces/WORKSPACE_NAME"" + {ParameterNameStorageAccountConnectionString}=""STORAGE_ACCOUNT_CONNECTION_STRING"" Out[]: Connected to Azure Quantum workspace WORKSPACE_NAME. - + ``` ".Dedent(), $@" - Connect to an Azure Quantum workspace and force a credential prompt: + Connect to an Azure Quantum workspace using individual parameters: ``` - In []: %azure.connect {ParameterNameRefresh} - {ParameterNameSubscriptionId}=SUBSCRIPTION_ID - {ParameterNameResourceGroupName}=RESOURCE_GROUP_NAME - {ParameterNameWorkspaceName}=WORKSPACE_NAME - {ParameterNameStorageAccountConnectionString}=CONNECTION_STRING + In []: %azure.connect {ParameterNameSubscriptionId}=""SUBSCRIPTION_ID"" + {ParameterNameResourceGroupName}=""RESOURCE_GROUP_NAME"" + {ParameterNameWorkspaceName}=""WORKSPACE_NAME"" + {ParameterNameStorageAccountConnectionString}=""STORAGE_ACCOUNT_CONNECTION_STRING"" + Out[]: Connected to Azure Quantum workspace WORKSPACE_NAME. + + ``` + The `{ParameterNameStorageAccountConnectionString}` parameter is necessary only if the + specified Azure Quantum workspace was not linked to a storage account at creation time. + ".Dedent(), + + $@" + Connect to an Azure Quantum workspace and force a credential prompt using + the `{ParameterNameRefresh}` option: + ``` + In []: %azure.connect {ParameterNameRefresh} {ParameterNameResourceId}=""/subscriptions/f846b2bd-d0e2-4a1d-8141-4c6944a9d387/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Quantum/Workspaces/WORKSPACE_NAME"" Out[]: To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code [login code] to authenticate. Connected to Azure Quantum workspace WORKSPACE_NAME. - + ``` - Use the `{ParameterNameRefresh}` option if you want to bypass any saved or cached + The `{ParameterNameRefresh}` option bypasses any saved or cached credentials when connecting to Azure. ".Dedent(), + + @" + Print information about the current connection: + ``` + In []: %azure.connect + Out[]: Connected to Azure Quantum workspace WORKSPACE_NAME. + + ``` + ".Dedent(), }, }) {} @@ -94,16 +115,40 @@ credentials when connecting to Azure. public override async Task RunAsync(string input, IChannel channel, CancellationToken cancellationToken) { var inputParameters = ParseInputParameters(input); - - var storageAccountConnectionString = inputParameters.DecodeParameter(ParameterNameStorageAccountConnectionString); - if (string.IsNullOrEmpty(storageAccountConnectionString)) + if (!inputParameters.Any()) { return await AzureClient.GetConnectionStatusAsync(channel); } - var subscriptionId = inputParameters.DecodeParameter(ParameterNameSubscriptionId); - var resourceGroupName = inputParameters.DecodeParameter(ParameterNameResourceGroupName); - var workspaceName = inputParameters.DecodeParameter(ParameterNameWorkspaceName); + var resourceId = inputParameters.DecodeParameter(ParameterNameResourceId, defaultValue: string.Empty); + var subscriptionId = string.Empty; + var resourceGroupName = string.Empty; + var workspaceName = string.Empty; + + // A valid resource ID looks like: + // /subscriptions/f846b2bd-d0e2-4a1d-8141-4c6944a9d387/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Quantum/Workspaces/WORKSPACE_NAME + var match = Regex.Match(resourceId, + @"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"); + if (match.Success) + { + // match.Groups will be a GroupCollection containing four Group objects: + // -> match.Groups[0]: The full resource ID for the Azure Quantum workspace + // -> match.Groups[1]: The Azure subscription ID + // -> match.Groups[2]: The Azure resource group name + // -> match.Groups[3]: The Azure Quantum workspace name + subscriptionId = match.Groups[1].Value; + resourceGroupName = match.Groups[2].Value; + workspaceName = match.Groups[3].Value; + } + else + { + // look for each of the parameters individually + subscriptionId = inputParameters.DecodeParameter(ParameterNameSubscriptionId, defaultValue: string.Empty); + resourceGroupName = inputParameters.DecodeParameter(ParameterNameResourceGroupName, defaultValue: string.Empty); + workspaceName = inputParameters.DecodeParameter(ParameterNameWorkspaceName, defaultValue: string.Empty); + } + + var storageAccountConnectionString = inputParameters.DecodeParameter(ParameterNameStorageAccountConnectionString, defaultValue: string.Empty); var refreshCredentials = inputParameters.DecodeParameter(ParameterNameRefresh, defaultValue: false); return await AzureClient.ConnectAsync( channel, @@ -114,4 +159,4 @@ public override async Task RunAsync(string input, IChannel chan refreshCredentials); } } -} \ No newline at end of file +} diff --git a/src/Core/Core.csproj b/src/Core/Core.csproj index 11460fc08e..872d3a96af 100644 --- a/src/Core/Core.csproj +++ b/src/Core/Core.csproj @@ -34,9 +34,9 @@ - - - + + + diff --git a/src/Jupyter/Magic/AbstractMagic.cs b/src/Jupyter/Magic/AbstractMagic.cs index 9ddcd9e81c..5e53235dbe 100644 --- a/src/Jupyter/Magic/AbstractMagic.cs +++ b/src/Jupyter/Magic/AbstractMagic.cs @@ -94,6 +94,8 @@ public static Dictionary ParseInputParameters(string input, stri var regex = new Regex(@"(\{.*\})|[^\s""]+(?:\s*=\s*)(?:""[^""]*""|[^\s""]*)*|[^\s""]+(?:""[^""]*""[^\s""]*)*|(?:""[^""]*""[^\s""]*)+"); var args = regex.Matches(input).Select(match => match.Value); + var regexBeginEndQuotes = new Regex(@"^['""]|['""]$"); + // If we are expecting a first inferred-name parameter, see if it exists. // If so, serialize it to the dictionary as JSON and remove it from the list of args. if (args.Any() && @@ -102,7 +104,7 @@ public static Dictionary ParseInputParameters(string input, stri !string.IsNullOrEmpty(firstParameterInferredName)) { using var writer = new StringWriter(); - Json.Serializer.Serialize(writer, args.First()); + Json.Serializer.Serialize(writer, regexBeginEndQuotes.Replace(args.First(), string.Empty)); inputParameters[firstParameterInferredName] = writer.ToString(); args = args.Skip(1); } @@ -123,14 +125,14 @@ public static Dictionary ParseInputParameters(string input, stri foreach (string arg in args) { var tokens = arg.Split("=", 2); - var key = tokens[0].Trim(); + var key = regexBeginEndQuotes.Replace(tokens[0].Trim(), string.Empty); var value = tokens.Length switch { // If there was no value provided explicitly, treat it as an implicit "true" value 1 => true as object, // Trim whitespace and also enclosing single-quotes or double-quotes before returning - 2 => Regex.Replace(tokens[1].Trim(), @"^['""]|['""]$", string.Empty) as object, + 2 => regexBeginEndQuotes.Replace(tokens[1].Trim(), string.Empty) as object, // We called arg.Split("=", 2), so there should never be more than 2 _ => throw new InvalidOperationException() diff --git a/src/Python/qsharp/azure.py b/src/Python/qsharp/azure.py index 04a7644998..32036f528a 100644 --- a/src/Python/qsharp/azure.py +++ b/src/Python/qsharp/azure.py @@ -131,6 +131,6 @@ def output(jobId : str = '', **params) -> Dict: return result def jobs(filter : str = '', **params) -> List[AzureJob]: - result = qsharp.client._execute_magic(f"azure.jobs {filter}", raise_on_stderr=False, **params) + result = qsharp.client._execute_magic(f"azure.jobs \"{filter}\"", raise_on_stderr=False, **params) if "error_code" in result: raise AzureError(result) return [AzureJob(job) for job in result] diff --git a/src/Python/qsharp/tests/test_azure.py b/src/Python/qsharp/tests/test_azure.py index 613aa0b42a..13ba002958 100644 --- a/src/Python/qsharp/tests/test_azure.py +++ b/src/Python/qsharp/tests/test_azure.py @@ -37,10 +37,10 @@ def test_empty_workspace(): assert exception_info.value.error_name == "NotConnected" targets = qsharp.azure.connect( - storageAccountConnectionString="test", - subscriptionId="test", - resourceGroupName="test", - workspaceName="test" + storage="test", + subscription="test", + resourceGroup="test", + workspace="test" ) assert targets == [] @@ -51,23 +51,58 @@ def test_empty_workspace(): jobs = qsharp.azure.jobs() assert jobs == [] -def test_workspace_with_providers(): +def test_workspace_create_with_parameters(): """ - Tests behavior of a mock workspace with mock providers. + Tests behavior of a mock workspace with providers, using parameters to connect. """ targets = qsharp.azure.connect( - storageAccountConnectionString="test", - subscriptionId="test", - resourceGroupName="test", - workspaceName="WorkspaceNameWithMockProviders" + storage="test", + subscription="test", + resourceGroup="test", + workspace="WorkspaceNameWithMockProviders" ) assert isinstance(targets, list) assert len(targets) > 0 + _test_workspace_with_providers_after_connection() + +def test_workspace_create_with_resource_id(): + """ + Tests behavior of a mock workspace with providers, using resource ID to connect. + """ + subscriptionId = "f846b2bd-d0e2-4a1d-8141-4c6944a9d387" + resourceGroupName = "test" + workspaceName = "WorkspaceNameWithMockProviders" + targets = qsharp.azure.connect( + resourceId=f"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Quantum/Workspaces/{workspaceName}") + assert isinstance(targets, list) + assert len(targets) > 0 + + _test_workspace_with_providers_after_connection() + _test_workspace_job_execution() + +def test_workspace_create_with_resource_id_and_storage(): + """ + Tests behavior of a mock workspace with providers, using resource ID and storage connection string to connect. + """ + subscriptionId = "f846b2bd-d0e2-4a1d-8141-4c6944a9d387" + resourceGroupName = "test" + workspaceName = "WorkspaceNameWithMockProviders" + storageAccountConnectionString = "test" + targets = qsharp.azure.connect( + resourceId=f"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Quantum/Workspaces/{workspaceName}", + storage=storageAccountConnectionString) + assert isinstance(targets, list) + assert len(targets) > 0 + + _test_workspace_with_providers_after_connection() + +def _test_workspace_with_providers_after_connection(): with pytest.raises(AzureError) as exception_info: qsharp.azure.target() assert exception_info.value.error_name == "NoTarget" + targets = qsharp.azure.connect() for target in targets: active_target = qsharp.azure.target(target.id) assert isinstance(active_target, AzureTarget) @@ -89,6 +124,7 @@ def test_workspace_with_providers(): assert isinstance(retrieved_job, AzureJob) assert job.id == retrieved_job.id +def _test_workspace_job_execution(): # Execute a workspace operation with parameters op = qsharp.QSharpCallable("Microsoft.Quantum.SanityTests.HelloAgain", None) @@ -96,7 +132,7 @@ def test_workspace_with_providers(): qsharp.azure.execute(op) assert exception_info.value.error_name == "JobSubmissionFailed" - histogram = qsharp.azure.execute(op, count=3, name="test") + histogram = qsharp.azure.execute(op, count=3, name="test", timeout=3, poll=0.5) assert isinstance(histogram, dict) retrieved_histogram = qsharp.azure.output() @@ -109,7 +145,6 @@ def test_workspace_with_providers(): assert len(jobs) == 2 # Check that job filtering works - jobs = qsharp.azure.jobs(job.id) - print(job.id) + jobs = qsharp.azure.jobs(jobs[0].id) assert isinstance(jobs, list) assert len(jobs) == 1 diff --git a/src/Tests/AzureClientMagicTests.cs b/src/Tests/AzureClientMagicTests.cs index 442cb75f27..e3ac7f2cf0 100644 --- a/src/Tests/AzureClientMagicTests.cs +++ b/src/Tests/AzureClientMagicTests.cs @@ -12,6 +12,7 @@ using Microsoft.Quantum.IQSharp; using Microsoft.Quantum.IQSharp.AzureClient; using Microsoft.Extensions.DependencyInjection; +using System; namespace Tests.IQSharp { @@ -27,7 +28,7 @@ public static void Test(this MagicSymbol magic, string input, ExecuteStatus expe [TestClass] public class AzureClientMagicTests { - private readonly string subscriptionId = "TEST_SUBSCRIPTION_ID"; + private readonly string subscriptionId = Guid.NewGuid().ToString(); private readonly string resourceGroupName = "TEST_RESOURCE_GROUP_NAME"; private readonly string workspaceName = "TEST_WORKSPACE_NAME"; private readonly string storageAccountConnectionString = "TEST_CONNECTION_STRING"; @@ -41,16 +42,40 @@ public void TestConnectMagic() var azureClient = new MockAzureClient(); var connectMagic = new ConnectMagic(azureClient); + // no input + connectMagic.Test(string.Empty); + Assert.AreEqual(AzureClientAction.GetConnectionStatus, azureClient.LastAction); + // unrecognized input connectMagic.Test($"invalid"); - Assert.AreEqual(azureClient.LastAction, AzureClientAction.GetConnectionStatus); + Assert.AreEqual(AzureClientAction.Connect, azureClient.LastAction); + + // valid input with resource ID + connectMagic.Test($"resourceId=/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Quantum/Workspaces/{workspaceName}"); + Assert.AreEqual(AzureClientAction.Connect, azureClient.LastAction); + Assert.IsFalse(azureClient.RefreshCredentials); + Assert.AreEqual(subscriptionId, azureClient.SubscriptionId); + Assert.AreEqual(resourceGroupName, azureClient.ResourceGroupName); + Assert.AreEqual(workspaceName, azureClient.WorkspaceName); + Assert.AreEqual(string.Empty, azureClient.ConnectionString); + + // valid input with resource ID and storage account connection string + connectMagic.Test( + @$"resourceId=/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Quantum/Workspaces/{workspaceName} + storage={storageAccountConnectionString}"); + Assert.AreEqual(AzureClientAction.Connect, azureClient.LastAction); + Assert.IsFalse(azureClient.RefreshCredentials); + Assert.AreEqual(subscriptionId, azureClient.SubscriptionId); + Assert.AreEqual(resourceGroupName, azureClient.ResourceGroupName); + Assert.AreEqual(workspaceName, azureClient.WorkspaceName); + Assert.AreEqual(storageAccountConnectionString, azureClient.ConnectionString); - // valid input + // valid input with individual parameters connectMagic.Test( - @$"subscriptionId={subscriptionId} - resourceGroupName={resourceGroupName} - workspaceName={workspaceName} - storageAccountConnectionString={storageAccountConnectionString}"); + @$"subscription={subscriptionId} + resourceGroup={resourceGroupName} + workspace={workspaceName} + storage={storageAccountConnectionString}"); Assert.AreEqual(AzureClientAction.Connect, azureClient.LastAction); Assert.IsFalse(azureClient.RefreshCredentials); Assert.AreEqual(subscriptionId, azureClient.SubscriptionId); @@ -60,10 +85,10 @@ public void TestConnectMagic() // valid input with extra whitespace and quotes connectMagic.Test( - @$"subscriptionId = {subscriptionId} - resourceGroupName= ""{resourceGroupName}"" - workspaceName ={workspaceName} - storageAccountConnectionString = '{storageAccountConnectionString}'"); + @$"subscription = {subscriptionId} + resourceGroup= ""{resourceGroupName}"" + workspace ={workspaceName} + storage = '{storageAccountConnectionString}'"); Assert.AreEqual(AzureClientAction.Connect, azureClient.LastAction); Assert.IsFalse(azureClient.RefreshCredentials); Assert.AreEqual(subscriptionId, azureClient.SubscriptionId); @@ -73,10 +98,10 @@ public void TestConnectMagic() // valid input with forced login connectMagic.Test( - @$"refresh subscriptionId={subscriptionId} - resourceGroupName={resourceGroupName} - workspaceName={workspaceName} - storageAccountConnectionString={storageAccountConnectionString}"); + @$"refresh subscription={subscriptionId} + resourceGroup={resourceGroupName} + workspace={workspaceName} + storage={storageAccountConnectionString}"); Assert.IsTrue(azureClient.RefreshCredentials); } diff --git a/src/Tool/appsettings.json b/src/Tool/appsettings.json index 221dde45bd..d5cbc6ab1e 100644 --- a/src/Tool/appsettings.json +++ b/src/Tool/appsettings.json @@ -6,25 +6,25 @@ }, "AllowedHosts": "*", "DefaultPackageVersions": [ - "Microsoft.Quantum.Compiler::0.11.2006.403", + "Microsoft.Quantum.Compiler::0.11.2006.1615-beta", - "Microsoft.Quantum.CsharpGeneration::0.11.2006.403", - "Microsoft.Quantum.Development.Kit::0.11.2006.403", - "Microsoft.Quantum.Simulators::0.11.2006.403", - "Microsoft.Quantum.Xunit::0.11.2006.403", + "Microsoft.Quantum.CsharpGeneration::0.11.2006.1615-beta", + "Microsoft.Quantum.Development.Kit::0.11.2006.1615-beta", + "Microsoft.Quantum.Simulators::0.11.2006.1615-beta", + "Microsoft.Quantum.Xunit::0.11.2006.1615-beta", - "Microsoft.Quantum.Standard::0.11.2006.403", - "Microsoft.Quantum.Chemistry::0.11.2006.403", - "Microsoft.Quantum.Chemistry.Jupyter::0.11.2006.403", - "Microsoft.Quantum.MachineLearning::0.11.2006.403", - "Microsoft.Quantum.Numerics::0.11.2006.403", + "Microsoft.Quantum.Standard::0.11.2006.1615-beta", + "Microsoft.Quantum.Chemistry::0.11.2006.1615-beta", + "Microsoft.Quantum.Chemistry.Jupyter::0.11.2006.1615-beta", + "Microsoft.Quantum.MachineLearning::0.11.2006.1615-beta", + "Microsoft.Quantum.Numerics::0.11.2006.1615-beta", - "Microsoft.Quantum.Katas::0.11.2006.403", + "Microsoft.Quantum.Katas::0.11.2006.1615-beta", - "Microsoft.Quantum.Research::0.11.2006.403", + "Microsoft.Quantum.Research::0.11.2006.1615-beta", - "Microsoft.Quantum.Providers.IonQ::0.11.2006.403", - "Microsoft.Quantum.Providers.Honeywell::0.11.2006.403", - "Microsoft.Quantum.Providers.QCI::0.11.2006.403", + "Microsoft.Quantum.Providers.IonQ::0.11.2006.1615-beta", + "Microsoft.Quantum.Providers.Honeywell::0.11.2006.1615-beta", + "Microsoft.Quantum.Providers.QCI::0.11.2006.1615-beta", ] }