azure-quantum 3.5.0.dev0__tar.gz → 3.5.1.dev0__tar.gz

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 3.5.0.dev0
+Version: 3.5.1.dev0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft
@@ -79,15 +79,14 @@ To get started, visit the following Quickstart guides:
 
 ## General usage ##
 
-To connect to your Azure Quantum Workspace, go to the [Azure Portal](https://portal.azure.com), navigate to your Workspace and copy-paste the resource ID and location into the code snippet below.
+To connect to your Azure Quantum Workspace, go to the [Azure Portal](https://portal.azure.com), navigate to your Workspace and copy-paste the resource ID into the code snippet below.
 
 ```python
 from azure.quantum import Workspace
 
-# Enter your Workspace details (resource ID and location) below
+# Enter your Workspace resource ID below
 workspace = Workspace(
-    resource_id="",
-    location=""
+    resource_id=""
 )
 ```
 

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/README.md

@@ -29,15 +29,14 @@ To get started, visit the following Quickstart guides:
 
 ## General usage ##
 
-To connect to your Azure Quantum Workspace, go to the [Azure Portal](https://portal.azure.com), navigate to your Workspace and copy-paste the resource ID and location into the code snippet below.
+To connect to your Azure Quantum Workspace, go to the [Azure Portal](https://portal.azure.com), navigate to your Workspace and copy-paste the resource ID into the code snippet below.
 
 ```python
 from azure.quantum import Workspace
 
-# Enter your Workspace details (resource ID and location) below
+# Enter your Workspace resource ID below
 workspace = Workspace(
-    resource_id="",
-    location=""
+    resource_id=""
 )
 ```
 

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure/quantum/_client/_version.py

@@ -6,4 +6,4 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "3.5.0.dev0"
+VERSION = "3.5.1.dev0"

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure/quantum/_constants.py

@@ -55,6 +55,9 @@ class ConnectionConstants:
     DATA_PLANE_CREDENTIAL_SCOPE = "https://quantum.microsoft.com/.default"
     ARM_CREDENTIAL_SCOPE = "https://management.azure.com/.default"
 
+    DEFAULT_ARG_API_VERSION = "2021-03-01"
+    DEFAULT_WORKSPACE_API_VERSION = "2025-11-01-preview"
+
     MSA_TENANT_ID = "9188040d-6c67-4c5b-b112-36a304b66dad"
 
     AUTHORITY = AzureIdentityInternals.get_default_authority()
@@ -63,10 +66,14 @@ class ConnectionConstants:
     # pylint: disable=unnecessary-lambda-assignment
     GET_QUANTUM_PRODUCTION_ENDPOINT = \
         lambda location: f"https://{location}.quantum.azure.com/"
+    GET_QUANTUM_PRODUCTION_ENDPOINT_v2 = \
+        lambda location: f"https://{location}-v2.quantum.azure.com/"
     GET_QUANTUM_CANARY_ENDPOINT = \
         lambda location: f"https://{location or 'eastus2euap'}.quantum.azure.com/"
     GET_QUANTUM_DOGFOOD_ENDPOINT = \
         lambda location: f"https://{location}.quantum-test.azure.com/"
+    GET_QUANTUM_DOGFOOD_ENDPOINT_v2 = \
+        lambda location: f"https://{location}-v2.quantum-test.azure.com/"
 
     ARM_PRODUCTION_ENDPOINT = "https://management.azure.com/"
     ARM_DOGFOOD_ENDPOINT = "https://api-dogfood.resources.windows-int.net/"
@@ -93,3 +100,65 @@ class ConnectionConstants:
 GUID_REGEX_PATTERN = (
     r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 )
+
+VALID_WORKSPACE_NAME_PATTERN = r"^[a-zA-Z0-9]+(-*[a-zA-Z0-9])*$"
+
+VALID_AZURE_REGIONS = {
+    "australiacentral",
+    "australiacentral2",
+    "australiaeast",
+    "australiasoutheast",
+    "austriaeast",
+    "belgiumcentral",
+    "brazilsouth",
+    "brazilsoutheast",
+    "canadacentral",
+    "canadaeast",
+    "centralindia",
+    "centralus",
+    "centraluseuap",
+    "chilecentral",
+    "eastasia",
+    "eastus",
+    "eastus2",
+    "eastus2euap",
+    "francecentral",
+    "francesouth",
+    "germanynorth",
+    "germanywestcentral",
+    "indonesiacentral",
+    "israelcentral",
+    "italynorth",
+    "japaneast",
+    "japanwest",
+    "koreacentral",
+    "koreasouth",
+    "malaysiawest",
+    "mexicocentral",
+    "newzealandnorth",
+    "northcentralus",
+    "northeurope",
+    "norwayeast",
+    "norwaywest",
+    "polandcentral",
+    "qatarcentral",
+    "southafricanorth",
+    "southafricawest",
+    "southcentralus",
+    "southindia",
+    "southeastasia",
+    "spaincentral",
+    "swedencentral",
+    "switzerlandnorth",
+    "switzerlandwest",
+    "uaecentral",
+    "uaenorth",
+    "uksouth",
+    "ukwest",
+    "westcentralus",
+    "westeurope",
+    "westindia",
+    "westus",
+    "westus2",
+    "westus3",
+}

azure_quantum-3.5.1.dev0/azure/quantum/_mgmt_client.py

@@ -0,0 +1,239 @@
+##
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+##
+"""
+Module providing the WorkspaceMgmtClient class for managing workspace operations.
+Created to do not add additional azure-mgmt-* dependencies that can conflict with existing ones.
+"""
+
+import logging
+from http import HTTPStatus
+from typing import Any, Optional, cast
+from azure.core import PipelineClient
+from azure.core.credentials import TokenProvider
+from azure.core.pipeline import policies
+from azure.core.rest import HttpRequest
+from azure.core.exceptions import HttpResponseError
+from azure.quantum._workspace_connection_params import WorkspaceConnectionParams
+from azure.quantum._constants import ConnectionConstants
+from azure.quantum._client._configuration import VERSION
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["WorkspaceMgmtClient"]
+
+
+class WorkspaceMgmtClient():
+    """
+    Client for Azure Quantum Workspace related ARM/ARG operations.
+    Uses PipelineClient under the hood which is standard for all Azure SDK clients,
+    see https://learn.microsoft.com/en-us/azure/developer/python/sdk/fundamentals/http-pipeline-retries.
+    
+    :param credential:
+        The credential to use to connect to Azure services.
+    
+    :param base_url:
+        The base URL for the ARM endpoint.
+    
+    :param user_agent:
+        Add the specified value as a prefix to the HTTP User-Agent header.
+    """
+
+    # Constants
+    DEFAULT_RETRY_TOTAL = 3
+    CONTENT_TYPE_JSON = "application/json"
+    CONNECT_DOC_LINK = "https://learn.microsoft.com/en-us/azure/quantum/how-to-connect-workspace"
+    CONNECT_DOC_MESSAGE = f"To find details on how to connect to your workspace, please see {CONNECT_DOC_LINK}."
+    
+    def __init__(self, credential: TokenProvider, base_url: str, user_agent: Optional[str] = None) -> None:
+        """
+        Initialize the WorkspaceMgmtClient.
+        
+        :param credential:
+            The credential to use to connect to Azure services.
+        
+        :param base_url:
+            The base URL for the ARM endpoint.
+        """
+        self._credential = credential
+        self._base_url = base_url
+        self._policies = [
+            policies.RequestIdPolicy(),
+            policies.HeadersPolicy({
+                "Content-Type": self.CONTENT_TYPE_JSON,
+                "Accept": self.CONTENT_TYPE_JSON,
+            }),
+            policies.UserAgentPolicy(user_agent=user_agent, sdk_moniker="quantum/{}".format(VERSION)),
+            policies.RetryPolicy(retry_total=self.DEFAULT_RETRY_TOTAL),
+            policies.BearerTokenCredentialPolicy(self._credential, ConnectionConstants.ARM_CREDENTIAL_SCOPE),
+        ]
+        self._client: PipelineClient = PipelineClient(base_url=cast(str, base_url), policies=self._policies)
+    
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> 'WorkspaceMgmtClient':
+        self._client.__enter__()
+        return self
+
+    def __exit__(self, *exc_details: Any) -> None:
+        self._client.__exit__(*exc_details)
+
+    def load_workspace_from_arg(self, connection_params: WorkspaceConnectionParams) -> None:
+        """
+        Queries Azure Resource Graph to find a workspace by name and optionally location, resource group, subscription.
+        Provided workspace name, location, resource group, and subscription in connection params must be validated beforehand.
+        
+        :param connection_params:
+            The workspace connection parameters to use and update.
+        """
+        if not connection_params.workspace_name:
+            raise ValueError("Workspace name must be specified to try to load workspace details from ARG.")
+
+        query = f"""
+            Resources
+            | where type =~ 'microsoft.quantum/workspaces'
+            | where name =~ '{connection_params.workspace_name}'
+        """
+        
+        if connection_params.resource_group:
+            query += f"\n                | where resourceGroup =~ '{connection_params.resource_group}'"
+        
+        if connection_params.location:
+            query += f"\n                | where location =~ '{connection_params.location}'"
+
+        query += """
+            | extend endpointUri = tostring(properties.endpointUri)
+            | project name, subscriptionId, resourceGroup, location, endpointUri
+        """
+
+        request_body = {
+            "query": query
+        }
+
+        if connection_params.subscription_id:
+            request_body["subscriptions"] = [connection_params.subscription_id]
+
+        # Create request to Azure Resource Graph API
+        request = HttpRequest(
+            method="POST",
+            url=self._client.format_url("/providers/Microsoft.ResourceGraph/resources"),
+            params={"api-version": ConnectionConstants.DEFAULT_ARG_API_VERSION},
+            json=request_body
+        )
+        
+        try:
+            response = self._client.send_request(request)
+            response.raise_for_status()
+            result = response.json()
+        except Exception as e:
+            raise RuntimeError(
+                f"Could not load workspace details from Azure Resource Graph: {str(e)}.\n{self.CONNECT_DOC_MESSAGE}"
+            ) from e
+        
+        data = result.get('data', [])
+        
+        if not data:
+            raise ValueError(f"No matching workspace found with name '{connection_params.workspace_name}'. {self.CONNECT_DOC_MESSAGE}")
+        
+        if len(data) > 1:
+            raise ValueError(
+                f"Multiple Azure Quantum workspaces found with name '{connection_params.workspace_name}'. "
+                f"Please specify additional connection parameters. {self.CONNECT_DOC_MESSAGE}"
+            )
+        
+        workspace_data = data[0]
+        
+        connection_params.subscription_id = workspace_data.get('subscriptionId')
+        connection_params.resource_group = workspace_data.get('resourceGroup')
+        connection_params.location = workspace_data.get('location')
+        connection_params.quantum_endpoint = workspace_data.get('endpointUri')
+
+        logger.debug(
+            "Found workspace '%s' in subscription '%s', resource group '%s', location '%s', endpoint '%s'",
+            connection_params.workspace_name,
+            connection_params.subscription_id,
+            connection_params.resource_group,
+            connection_params.location,
+            connection_params.quantum_endpoint
+        )
+
+        # If one of the required parameters is missing, probably workspace in failed provisioning state
+        if not connection_params.is_complete():
+            raise ValueError(
+                f"Failed to retrieve complete workspace details for workspace '{connection_params.workspace_name}'. "
+                "Please check that workspace is in valid state."
+            )
+        
+    def load_workspace_from_arm(self, connection_params: WorkspaceConnectionParams) -> None:
+        """
+        Fetches the workspace resource from ARM and sets location and endpoint URI params.
+        Provided workspace name, resource group, and subscription in connection params must be validated beforehand.
+        
+        :param connection_params:
+            The workspace connection parameters to use and update.
+        """
+        if not all([connection_params.subscription_id, connection_params.resource_group, connection_params.workspace_name]):
+            raise ValueError("Missing required connection parameters to load workspace details from ARM.")
+        
+        api_version = connection_params.api_version or ConnectionConstants.DEFAULT_WORKSPACE_API_VERSION
+        
+        url = (
+            f"/subscriptions/{connection_params.subscription_id}"
+            f"/resourceGroups/{connection_params.resource_group}"
+            f"/providers/Microsoft.Quantum/workspaces/{connection_params.workspace_name}"
+        )
+
+        request = HttpRequest(
+            method="GET",
+            url=self._client.format_url(url),
+            params={"api-version": api_version},
+        )
+        
+        try:
+            response = self._client.send_request(request)
+            response.raise_for_status()
+            workspace_data = response.json()
+        except HttpResponseError as e:
+            if e.status_code == HTTPStatus.NOT_FOUND:
+                raise ValueError(
+                    f"Azure Quantum workspace '{connection_params.workspace_name}' "
+                    f"not found in resource group '{connection_params.resource_group}' "
+                    f"and subscription '{connection_params.subscription_id}'. "
+                    f"{self.CONNECT_DOC_MESSAGE}"
+                ) from e
+            # Re-raise for other HTTP errors
+            raise
+        except Exception as e:
+            raise RuntimeError(
+                f"Could not load workspace details from ARM: {str(e)}.\n{self.CONNECT_DOC_MESSAGE}"
+            ) from e
+
+        # Extract and apply location
+        location = workspace_data.get("location")
+        if location:
+            connection_params.location = location
+            logger.debug(
+                "Updated workspace location from ARM: %s",
+                location
+            )
+        else:
+            raise ValueError(
+                f"Failed to retrieve location for workspace '{connection_params.workspace_name}'. "
+                f"Please check that workspace is in valid state."
+            )
+
+        # Extract and apply endpoint URI from properties
+        properties = workspace_data.get("properties", {})
+        endpoint_uri = properties.get("endpointUri")
+        if endpoint_uri:
+            connection_params.quantum_endpoint = endpoint_uri
+            logger.debug(
+                "Updated workspace endpoint from ARM: %s", connection_params.quantum_endpoint
+            )
+        else:
+            raise ValueError(
+                f"Failed to retrieve endpoint uri for workspace '{connection_params.workspace_name}'. "
+                f"Please check that workspace is in valid state."
+            )

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure/quantum/_workspace_connection_params.py

@@ -20,6 +20,8 @@ from azure.quantum._constants import (
     EnvironmentVariables,
     ConnectionConstants,
     GUID_REGEX_PATTERN,
+    VALID_WORKSPACE_NAME_PATTERN,
+    VALID_AZURE_REGIONS,
 )
 
 class WorkspaceConnectionParams:
@@ -46,9 +48,19 @@ class WorkspaceConnectionParams:
             ResourceGroupName=(?P<resource_group>[^\s;]+);
             WorkspaceName=(?P<workspace_name>[^\s;]+);
             ApiKey=(?P<api_key>[^\s;]+);
-            QuantumEndpoint=(?P<quantum_endpoint>https://(?P<location>[^\s\.]+).quantum(?:-test)?.azure.com/);
+            QuantumEndpoint=(?P<quantum_endpoint>https://(?P<location>[a-zA-Z0-9]+)(?:-v2)?.quantum(?:-test)?.azure.com/);
         """,
         re.VERBOSE | re.IGNORECASE)
+    
+    WORKSPACE_NOT_FULLY_SPECIFIED_MSG = """
+        Azure Quantum workspace not fully specified.
+        Please specify one of the following:
+        1) A valid resource ID.
+        2) A valid combination of subscription ID,
+        resource group name, and workspace name.
+        3) A valid connection string (via Workspace.from_connection_string()).
+        4) A valid workspace name.
+    """
 
     def __init__(
         self,
@@ -85,6 +97,8 @@ class WorkspaceConnectionParams:
         self.client_id = None
         self.tenant_id = None
         self.api_version = None
+        # Track if connection string was used
+        self._used_connection_string = False
         # callback to create a new client if needed
         # for example, when changing the user agent
         self.on_new_client_request = on_new_client_request
@@ -108,6 +122,81 @@ class WorkspaceConnectionParams:
             workspace_name=workspace_name,
         )
         self.apply_resource_id(resource_id=resource_id)
+        # Validate connection parameters if they are set
+        self._validate_connection_params()
+
+    def _validate_connection_params(self):
+        self._validate_subscription_id()
+        self._validate_resource_group()
+        self._validate_workspace_name()
+        self._validate_location()
+    
+    def _validate_subscription_id(self):
+        # Validate that subscription id is a valid GUID
+        if self.subscription_id is not None:
+            if not isinstance(self.subscription_id, str):
+                raise ValueError("Subscription ID must be a string.")
+            if not re.match(f"^{GUID_REGEX_PATTERN}$", self.subscription_id, re.IGNORECASE):
+                raise ValueError("Subscription ID must be a valid GUID.")
+    
+    def _validate_resource_group(self):
+        # Validate resource group, see https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/resource-name-rules#microsoftresources
+        # Length 1-90, valid characters: alphanumeric, underscore, parentheses, hyphen, period (except at end), and Unicode characters:
+        # Uppercase Letter - Signified by the Unicode designation "Lu" (letter, uppercase);
+        # Lowercase Letter - Signified by the Unicode designation "Ll" (letter, lowercase);
+        # Titlecase Letter - Signified by the Unicode designation "Lt" (letter, titlecase);
+        # Modifier Letter - Signified by the Unicode designation "Lm" (letter, modifier);
+        # Other Letter - Signified by the Unicode designation "Lo" (letter, other);
+        # Decimal Digit Number - Signified by the Unicode designation "Nd" (number, decimal digit).
+        if self.resource_group is not None:
+            if not isinstance(self.resource_group, str):
+                raise ValueError("Resource group name must be a string.")
+            
+            if len(self.resource_group) < 1 or len(self.resource_group) > 90:
+                raise ValueError(
+                    "Resource group name must be between 1 and 90 characters long."
+                )
+            
+            err_msg =  "Resource group name can only include alphanumeric, underscore, parentheses, hyphen, period (except at end), and Unicode characters that match the allowed characters."
+            if self.resource_group.endswith('.'):
+                raise ValueError(err_msg)
+            
+            import unicodedata
+            for i, char in enumerate(self.resource_group):
+                category = unicodedata.category(char)
+                if not (
+                    char in ('_', '(', ')', '-', '.') or
+                    category in ('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nd')
+                ):
+                    raise ValueError(err_msg)
+    
+    def _validate_workspace_name(self):
+        # Validate workspace name, see https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/resource-name-rules#microsoftquantum
+        # Length 2-54, valid characters: alphanumerics (a-zA-Z0-9) and hyphens, can't start or end with hyphen
+        if self.workspace_name is not None:
+            if not isinstance(self.workspace_name, str):
+                raise ValueError("Workspace name must be a string.")
+            
+            if len(self.workspace_name) < 2 or len(self.workspace_name) > 54:
+                raise ValueError(
+                    "Workspace name must be between 2 and 54 characters long."
+                )
+            
+            err_msg = "Workspace name can only include alphanumerics (a-zA-Z0-9) and hyphens, and cannot start or end with hyphen."
+
+            if self.workspace_name.startswith('-') or self.workspace_name.endswith('-'):
+                raise ValueError(err_msg)
+            
+            if not re.match(VALID_WORKSPACE_NAME_PATTERN, self.workspace_name):
+                raise ValueError(err_msg)
+    
+    def _validate_location(self):
+        # Validate that location is one of the Azure regions https://learn.microsoft.com/en-us/azure/reliability/regions-list
+        if self.location is not None:
+            if not isinstance(self.location, str):
+                raise ValueError("Location must be a string.")
+            if self.location not in VALID_AZURE_REGIONS:
+                raise ValueError(f"Location must be one of the Azure regions listed in https://learn.microsoft.com/en-us/azure/reliability/regions-list.")
 
     @property
     def location(self):
@@ -142,19 +231,8 @@ class WorkspaceConnectionParams:
     def quantum_endpoint(self):
         """
         The Azure Quantum data plane endpoint.
-        Defaults to well-known endpoint based on the environment.
-        """
-        if self._quantum_endpoint:
-            return self._quantum_endpoint
-        if not self.location:
-            raise ValueError("Location not specified")
-        if self.environment is EnvironmentKind.PRODUCTION:
-            return ConnectionConstants.GET_QUANTUM_PRODUCTION_ENDPOINT(self.location)
-        if self.environment is EnvironmentKind.CANARY:
-            return ConnectionConstants.GET_QUANTUM_CANARY_ENDPOINT(self.location)
-        if self.environment is EnvironmentKind.DOGFOOD:
-            return ConnectionConstants.GET_QUANTUM_DOGFOOD_ENDPOINT(self.location)
-        raise ValueError(f"Unknown environment `{self.environment}`.")
+        """
+        return self._quantum_endpoint
 
     @quantum_endpoint.setter
     def quantum_endpoint(self, value: str):
@@ -235,6 +313,7 @@ class WorkspaceConnectionParams:
             if not match:
                 raise ValueError("Invalid connection string")
             self._merge_re_match(match)
+            self._used_connection_string = True
 
     def merge(
         self,
@@ -450,6 +529,32 @@ class WorkspaceConnectionParams:
             full_user_agent = (f"{app_id} {full_user_agent}"
                                if full_user_agent else app_id)
         return full_user_agent
+    
+    def have_enough_for_discovery(self) -> bool:
+        """
+        Returns true if we have enough parameters
+        to try to find the Azure Quantum Workspace.
+        """
+        return (self.workspace_name
+                and self.get_credential_or_default())
+
+    def assert_have_enough_for_discovery(self):
+        """
+        Raises ValueError if we don't have enough parameters
+        to try to find the Azure Quantum Workspace.
+        """
+        if not self.have_enough_for_discovery():
+            raise ValueError(self.WORKSPACE_NOT_FULLY_SPECIFIED_MSG)
+    
+    def can_build_resource_id(self) -> bool:
+        """
+        Returns true if we have all necessary parameters
+        to identify the Azure Quantum Workspace resource.
+        """
+        return (self.subscription_id
+                and self.resource_group
+                and self.workspace_name
+                and self.get_credential_or_default())
 
     def is_complete(self) -> bool:
         """
@@ -460,6 +565,7 @@ class WorkspaceConnectionParams:
                 and self.subscription_id
                 and self.resource_group
                 and self.workspace_name
+                and self.quantum_endpoint
                 and self.get_credential_or_default())
 
     def assert_complete(self):
@@ -468,15 +574,7 @@ class WorkspaceConnectionParams:
         to connect to the Azure Quantum Workspace.
         """
         if not self.is_complete():
-            raise ValueError(
-                """
-                    Azure Quantum workspace not fully specified.
-                    Please specify one of the following:
-                    1) A valid combination of location and resource ID.
-                    2) A valid combination of location, subscription ID,
-                    resource group name, and workspace name.
-                    3) A valid connection string (via Workspace.from_connection_string()).
-                """)
+            raise ValueError(self.WORKSPACE_NOT_FULLY_SPECIFIED_MSG)
 
     def default_from_env_vars(self) -> WorkspaceConnectionParams:
         """
@@ -512,10 +610,13 @@ class WorkspaceConnectionParams:
             or not self.workspace_name
             or not self.credential
         ):
-            self._merge_connection_params(
-                connection_params=WorkspaceConnectionParams(
-                    connection_string=os.environ.get(EnvironmentVariables.CONNECTION_STRING)),
-                merge_default_mode=True)
+            env_connection_string = os.environ.get(EnvironmentVariables.CONNECTION_STRING)
+            if env_connection_string:
+                self._merge_connection_params(
+                    connection_params=WorkspaceConnectionParams(
+                        connection_string=env_connection_string),
+                    merge_default_mode=True)
+                self._used_connection_string = True
         return self
 
     @classmethod

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure/quantum/version.py

@@ -5,4 +5,4 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 ##
-__version__ = "3.5.0.dev0"
+__version__ = "3.5.1.dev0"

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure/quantum/workspace.py

@@ -21,6 +21,7 @@ from typing import (
     Tuple,
     Union,
 )
+from typing_extensions import Self
 from azure.core.paging import ItemPaged
 from azure.quantum._client import ServicesClient
 from azure.quantum._client.models import JobDetails, ItemDetails, SessionDetails
@@ -49,6 +50,7 @@ from azure.quantum.storage import (
     get_container_uri,
     ContainerClient
 )
+from azure.quantum._mgmt_client import WorkspaceMgmtClient
 if TYPE_CHECKING:
     from azure.quantum.target import Target
 
@@ -62,10 +64,11 @@ class Workspace:
     """
     Represents an Azure Quantum workspace.
 
-    When creating a Workspace object, callers have two options for
+    When creating a Workspace object, callers have several options for
     identifying the Azure Quantum workspace (in order of precedence):
-    1. specify a valid location and resource ID; or
-    2. specify a valid location, subscription ID, resource group, and workspace name.
+    1. specify a valid resource ID; or
+    2. specify a valid subscription ID, resource group, and workspace name; or
+    3. specify a valid workspace name.
 
     You can also use a connection string to specify the connection parameters
     to an Azure Quantum Workspace by calling
@@ -110,6 +113,12 @@ class Workspace:
         Add the specified value as a prefix to the HTTP User-Agent header
         when communicating to the Azure Quantum service.
     """
+    
+    # Internal parameter names
+    _FROM_CONNECTION_STRING_PARAM = '_from_connection_string'
+    _QUANTUM_ENDPOINT_PARAM = '_quantum_endpoint'
+    _MGMT_CLIENT_PARAM = '_mgmt_client'
+    
     def __init__(
         self,
         subscription_id: Optional[str] = None,
@@ -122,6 +131,14 @@ class Workspace:
         user_agent: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
+        # Extract internal params before passing kwargs to WorkspaceConnectionParams
+        # Param to track whether the workspace was created from a connection string
+        from_connection_string = kwargs.pop(Workspace._FROM_CONNECTION_STRING_PARAM, False)
+        # In case from connection string, quantum_endpoint must be passed
+        quantum_endpoint = kwargs.pop(Workspace._QUANTUM_ENDPOINT_PARAM, None)
+        # Params to pass a mock in tests
+        self._mgmt_client = kwargs.pop(Workspace._MGMT_CLIENT_PARAM, None)
+        
         connection_params = WorkspaceConnectionParams(
             location=location,
             subscription_id=subscription_id,
@@ -129,13 +146,14 @@ class Workspace:
             workspace_name=name,
             credential=credential,
             resource_id=resource_id,
+            quantum_endpoint=quantum_endpoint,
             user_agent=user_agent,
             **kwargs
         ).default_from_env_vars()
 
         logger.info("Using %s environment.", connection_params.environment)
 
-        connection_params.assert_complete()
+        connection_params.assert_have_enough_for_discovery()
 
         connection_params.on_new_client_request = self._on_new_client_request
 
@@ -145,6 +163,32 @@ class Workspace:
         self._resource_group = connection_params.resource_group
         self._workspace_name = connection_params.workspace_name
 
+        if not self._mgmt_client:
+            credential = connection_params.get_credential_or_default()
+            self._mgmt_client = WorkspaceMgmtClient(
+                credential=credential, 
+                base_url=connection_params.arm_endpoint, 
+                user_agent=connection_params.get_full_user_agent(),
+            )
+        
+        # pylint: disable=protected-access
+        using_connection_string = (
+            from_connection_string
+            or connection_params._used_connection_string
+        )
+
+        # Populate workspace details from ARG if not using connection string and 
+        # name is provided but missing subscription and/or resource group
+        if not using_connection_string \
+           and not connection_params.can_build_resource_id():
+            self._mgmt_client.load_workspace_from_arg(connection_params)
+
+        # Populate workspace details from ARM if not using connection string and not loaded from ARG
+        if not using_connection_string and not connection_params.is_complete():
+            self._mgmt_client.load_workspace_from_arm(connection_params)
+        
+        connection_params.assert_complete()
+
         # Create QuantumClient
         self._client = self._create_client()
 
@@ -277,6 +321,8 @@ class Workspace:
         :rtype: Workspace
         """
         connection_params = WorkspaceConnectionParams(connection_string=connection_string)
+        kwargs[cls._FROM_CONNECTION_STRING_PARAM] = True
+        kwargs[cls._QUANTUM_ENDPOINT_PARAM] = connection_params.quantum_endpoint
         return cls(
             subscription_id=connection_params.subscription_id,
             resource_group=connection_params.resource_group,
@@ -1023,4 +1069,16 @@ class Workspace:
             return orderby
         else:
             return None
-    
+    
+    def close(self) -> None:
+        self._mgmt_client.close()
+        self._client.close()
+
+    def __enter__(self) -> Self:
+        self._client.__enter__()
+        self._mgmt_client.__enter__()
+        return self
+
+    def __exit__(self, *exc_details: Any) -> None:
+        self._mgmt_client.__exit__(*exc_details)
+        self._client.__exit__(*exc_details)

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure_quantum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 3.5.0.dev0
+Version: 3.5.1.dev0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft
@@ -79,15 +79,14 @@ To get started, visit the following Quickstart guides:
 
 ## General usage ##
 
-To connect to your Azure Quantum Workspace, go to the [Azure Portal](https://portal.azure.com), navigate to your Workspace and copy-paste the resource ID and location into the code snippet below.
+To connect to your Azure Quantum Workspace, go to the [Azure Portal](https://portal.azure.com), navigate to your Workspace and copy-paste the resource ID into the code snippet below.
 
 ```python
 from azure.quantum import Workspace
 
-# Enter your Workspace details (resource ID and location) below
+# Enter your Workspace resource ID below
 workspace = Workspace(
-    resource_id="",
-    location=""
+    resource_id=""
 )
 ```
 

{azure_quantum-3.5.0.dev0 → azure_quantum-3.5.1.dev0}/azure_quantum.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ requirements.txt
 setup.py
 azure/quantum/__init__.py
 azure/quantum/_constants.py
+azure/quantum/_mgmt_client.py
 azure/quantum/_workspace_connection_params.py
 azure/quantum/storage.py
 azure/quantum/version.py