azure-quantum 3.5.0.dev0__py3-none-any.whl → 3.5.1.dev1__py3-none-any.whl

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.dev1"

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/_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/_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/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.dev1"

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,21 +146,45 @@ 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
 
         self._connection_params = connection_params
         self._storage = storage
-        self._subscription_id = connection_params.subscription_id
-        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 +318,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,
@@ -358,9 +401,9 @@ class Workspace:
             container_name=container_name, blob_name=blob_name
         )
         container_uri = client.get_sas_uri(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name, 
+            self.subscription_id,
+            self.resource_group,
+            self.name, 
             blob_details=blob_details)
 
         logger.debug("Container URI from service: %s", container_uri)
@@ -378,9 +421,9 @@ class Workspace:
         """
         client = self._get_jobs_client()
         details = client.create_or_replace(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name,
+            self.subscription_id,
+            self.resource_group,
+            self.name,
             job.details.id, 
             job.details
         )
@@ -399,14 +442,14 @@ class Workspace:
         """
         client = self._get_jobs_client()
         client.delete(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name,
+            self.subscription_id,
+            self.resource_group,
+            self.name,
             job.details.id)
         details = client.get(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name,
+            self.subscription_id,
+            self.resource_group,
+            self.name,
             job.id)
         return Job(self, details)
 
@@ -426,9 +469,9 @@ class Workspace:
 
         client = self._get_jobs_client()
         details = client.get(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name,
+            self.subscription_id,
+            self.resource_group,
+            self.name,
             job_id)
         target_factory = TargetFactory(base_cls=Target, workspace=self)
         # pylint: disable=protected-access
@@ -511,7 +554,7 @@ class Workspace:
         )
         orderby = self._create_orderby(orderby_property, is_asc)
 
-        return client.list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self._workspace_name, filter=job_filter, orderby=orderby, top = top, skip = skip)
+        return client.list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self.name, filter=job_filter, orderby=orderby, top = top, skip = skip)
 
     def _get_target_status(
             self,
@@ -534,9 +577,9 @@ class Workspace:
         return [
             (provider.id, target)
             for provider in self._client.providers.list(
-                self._subscription_id,
-                self._resource_group,
-                self._workspace_name)
+                self.subscription_id,
+                self.resource_group,
+                self.name)
             for target in provider.targets
             if (provider_id is None or provider.id.lower() == provider_id.lower())
                 and (name is None or target.id.lower() == name.lower())
@@ -593,9 +636,9 @@ class Workspace:
         """
         client = self._get_quotas_client()
         return [q.as_dict() for q in client.list(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name
+            self.subscription_id,
+            self.resource_group,
+            self.name
         )]
 
     def list_top_level_items(
@@ -666,7 +709,7 @@ class Workspace:
         )
         orderby = self._create_orderby(orderby_property, is_asc)
 
-        return client.list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self._workspace_name, filter=top_level_item_filter, orderby=orderby, top = top, skip = skip)
+        return client.list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self.name, filter=top_level_item_filter, orderby=orderby, top = top, skip = skip)
 
     def list_sessions(
         self,
@@ -727,7 +770,7 @@ class Workspace:
 
         orderby = self._create_orderby(orderby_property=orderby_property, is_asc=is_asc)
 
-        return client.list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self._workspace_name, filter = session_filter, orderby=orderby, skip=skip, top=top)
+        return client.list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self.name, filter = session_filter, orderby=orderby, skip=skip, top=top)
 
     def open_session(
         self,
@@ -744,9 +787,9 @@ class Workspace:
         """
         client = self._get_sessions_client()
         session.details = client.create_or_replace(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name,
+            self.subscription_id,
+            self.resource_group,
+            self.name,
             session.id,
             session.details)
 
@@ -765,15 +808,15 @@ class Workspace:
         client = self._get_sessions_client()
         if not session.is_in_terminal_state():
             session.details = client.close(
-                self._subscription_id,
-                self._resource_group,
-                self._workspace_name,
+                self.subscription_id,
+                self.resource_group,
+                self.name,
                 session_id=session.id)
         else:
             session.details = client.get(
-                self._subscription_id,
-                self._resource_group,
-                self._workspace_name,
+                self.subscription_id,
+                self.resource_group,
+                self.name,
                 session_id=session.id)
 
         if session.target:
@@ -809,9 +852,9 @@ class Workspace:
         """
         client = self._get_sessions_client()
         session_details = client.get(
-            self._subscription_id,
-            self._resource_group,
-            self._workspace_name,
+            self.subscription_id,
+            self.resource_group,
+            self.name,
             session_id=session_id)
         result = Session(workspace=self, details=session_details)
         return result
@@ -873,7 +916,7 @@ class Workspace:
 
         orderby = self._create_orderby(orderby_property=orderby_property, is_asc=is_asc)
 
-        return client.jobs_list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self._workspace_name, session_id=session_id, filter = session_job_filter, orderby=orderby, skip=skip, top=top)
+        return client.jobs_list(subscription_id=self.subscription_id, resource_group_name=self.resource_group, workspace_name=self.name, session_id=session_id, filter = session_job_filter, orderby=orderby, skip=skip, top=top)
 
     def get_container_uri(
         self,
@@ -1023,4 +1066,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.dist-info → azure_quantum-3.5.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 3.5.0.dev0
+Version: 3.5.1.dev1
 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.dist-info → azure_quantum-3.5.1.dev1.dist-info}/RECORD

@@ -1,16 +1,17 @@
 azure/quantum/__init__.py,sha256=Za8xZY4lzFkW8m4ero-bqrfN437D2NRukM77ukb4GPM,508
-azure/quantum/_constants.py,sha256=nDL_QrGdI_Zz_cvTB9nVgfE7J6A_Boo1ollMYqsiEBs,3499
-azure/quantum/_workspace_connection_params.py,sha256=70T6JHa72tPLM5i7IEIBMbqa3gxXXtDmu_uORWloo50,21553
+azure/quantum/_constants.py,sha256=EVGCZh2TJPkTOvti5Wq2V9mRFf4_gueiRZrXtCcPO9I,5110
+azure/quantum/_mgmt_client.py,sha256=9aCLHsrjLMnWKWkWOpRkW6fMQeSRbIy13q4Rjx4z_W8,10253
+azure/quantum/_workspace_connection_params.py,sha256=lVJpEdX6qz4MywnCv2h2ANFQYJJXRDAVNf5MfobLWnM,26636
 azure/quantum/storage.py,sha256=_4bMniDk9LrB_K5CQwuCivJFZXdmhRvU2b6Z3xxXw9I,12556
-azure/quantum/version.py,sha256=0IKkbEdcvscSEt1GMWf4Ok5ZgtBarauA8zjtpkTZpHg,240
-azure/quantum/workspace.py,sha256=9oO4vjwIn1pdHFLZCQcEPQ_xjQjTNO4UIWSBQpj6Cgo,35574
+azure/quantum/version.py,sha256=Sz0V0lSXVDypobmOgKo14ja7lYHWL0GCDWQkcxa3ibE,240
+azure/quantum/workspace.py,sha256=dc2xWEismuh4MI0lDqhsWKBj8ik4gTk98nANVKoWbcQ,37833
 azure/quantum/_client/__init__.py,sha256=P3K9ffYchHhHjJhCEAEwutSD3xRW92XDUQNYDjwhYqI,1056
 azure/quantum/_client/_client.py,sha256=7MRvLQZYcg0PKf906ulEOtF6H22Km1aa0FFj3O6LxXc,6734
 azure/quantum/_client/_configuration.py,sha256=FFUHJPp6X0015GpD-YLmYCoq8GI86nHCnDS_THTSHbg,4184
 azure/quantum/_client/_model_base.py,sha256=hu7OdRS2Ra1igfBo-R3zS3dzO3YhFC4FGHJ_WiyZgNg,43736
 azure/quantum/_client/_patch.py,sha256=YTV6yZ9bRfBBaw2z7v4MdzR-zeHkdtKkGb4SU8C25mE,694
 azure/quantum/_client/_serialization.py,sha256=bBl0y0mh-0sDd-Z8_dj921jQQhqhYWTOl59qSLuk01M,86686
-azure/quantum/_client/_version.py,sha256=ERfqFUpSSHTzPMC0LLLdaaXm30TV2v719rPGNSuyYXo,500
+azure/quantum/_client/_version.py,sha256=aO-J45LO8r4dDvSR1zoTgMYrlW9lfwE_c0B_5v5XJJY,500
 azure/quantum/_client/py.typed,sha256=dcrsqJrcYfTX-ckLFJMTaj6mD8aDe2u0tkQG-ZYxnEg,26
 azure/quantum/_client/models/__init__.py,sha256=MR2av7s_tCP66hicN9JXCmTngJ4_-ozM4cmblGjPwn8,1971
 azure/quantum/_client/models/_enums.py,sha256=oSJm7cDvyRwYQLZ50XLNWEfHJJ5c_XG8MlOux2PFT7Q,4706
@@ -58,7 +59,7 @@ azure/quantum/target/pasqal/target.py,sha256=K_vqavov6gvS84voRKeBx9pO8g4LrtWrlZ5
 azure/quantum/target/rigetti/__init__.py,sha256=I1vyzZBYGI540pauTqJd0RSSyTShGqkEL7Yjo25_RNY,378
 azure/quantum/target/rigetti/result.py,sha256=Xdb5LSwOkJssluDVDhg2gxHLgdvXpwCmA9QMr3jx3VA,2372
 azure/quantum/target/rigetti/target.py,sha256=HFrng9SigibPn_2KWhD5qWHiP_RNz3CNRkv288tf-z8,7586
-azure_quantum-3.5.0.dev0.dist-info/METADATA,sha256=bAE_JpdePnEXVdj0s9lR9ELahtuMC5C4Y7vZqtQnkwA,6759
-azure_quantum-3.5.0.dev0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-azure_quantum-3.5.0.dev0.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
-azure_quantum-3.5.0.dev0.dist-info/RECORD,,
+azure_quantum-3.5.1.dev1.dist-info/METADATA,sha256=i3nrDPBrZdu7BK-3DrTL4rFioTxc381x1_x6VluZEkI,6705
+azure_quantum-3.5.1.dev1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+azure_quantum-3.5.1.dev1.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
+azure_quantum-3.5.1.dev1.dist-info/RECORD,,