azure-quantum 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

azure/quantum/_authentication/_default.py

@@ -1,153 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-import logging
-import re
-from typing import Optional
-import urllib3
-from azure.core.credentials import AccessToken
-from azure.identity import (
-    AzurePowerShellCredential,
-    EnvironmentCredential,
-    ManagedIdentityCredential,
-    AzureCliCredential,
-    VisualStudioCodeCredential,
-    InteractiveBrowserCredential,
-    DeviceCodeCredential,
-    _internal as AzureIdentityInternals,
-)
-from ._chained import _ChainedTokenCredential
-from ._token import _TokenFileCredential
-from azure.quantum._constants import ConnectionConstants
-
-_LOGGER = logging.getLogger(__name__)
-WWW_AUTHENTICATE_REGEX = re.compile(
-    r"""
-        ^
-        Bearer\sauthorization_uri="
-            https://(?P<authority>[^/]*)/
-            (?P<tenant_id>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})
-        "
-    """,
-    re.VERBOSE | re.IGNORECASE)
-WWW_AUTHENTICATE_HEADER_NAME = "WWW-Authenticate"
-
-
-class _DefaultAzureCredential(_ChainedTokenCredential):
-    """
-    Based on Azure.Identity.DefaultAzureCredential from:
-    https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/identity/azure-identity/azure/identity/_credentials/default.py
-
-    The three key differences are:
-    1) Inherit from _ChainedTokenCredential, which has 
-       more aggressive error handling than ChainedTokenCredential
-    2) Instantiate the internal credentials the first time the get_token gets called
-       such that we can get the tenant_id if it was not passed by the user (but we don't
-       want to do that in the constructor).
-       We automatically identify the user's tenant_id for a given subscription 
-       so that users with MSA accounts don't need to pass it.
-       This is a mitigation for bug https://github.com/Azure/azure-sdk-for-python/issues/18975
-       We need the following parameters to enable auto-detection of tenant_id
-       - subscription_id
-       - arm_endpoint (defaults to the production url "https://management.azure.com/")
-    3) Add custom TokenFileCredential as first method to attempt,
-       which will look for a local access token.
-    """
-    def __init__(
-        self,
-        arm_endpoint: str,
-        subscription_id: str,
-        client_id: Optional[str] = None,
-        tenant_id: Optional[str] = None,
-        authority: Optional[str] = None,
-    ):
-        if arm_endpoint is None:
-            raise ValueError("arm_endpoint is mandatory parameter")
-        if subscription_id is None:
-            raise ValueError("subscription_id is mandatory parameter")
-
-        self.authority = self._authority_or_default(
-            authority=authority,
-            arm_endpoint=arm_endpoint)
-        self.tenant_id = tenant_id
-        self.subscription_id = subscription_id
-        self.arm_endpoint = arm_endpoint
-        self.client_id = client_id
-        # credentials will be created lazy on the first call to get_token
-        super(_DefaultAzureCredential, self).__init__()
-
-    def _authority_or_default(self, authority: str, arm_endpoint: str):
-        if authority:
-            return AzureIdentityInternals.normalize_authority(authority)
-        if arm_endpoint == ConnectionConstants.ARM_DOGFOOD_ENDPOINT:
-            return ConnectionConstants.DOGFOOD_AUTHORITY
-        return ConnectionConstants.AUTHORITY
-
-    def _initialize_credentials(self):
-        self._discover_tenant_id_(
-            arm_endpoint=self.arm_endpoint,
-            subscription_id=self.subscription_id)
-        credentials = []
-        credentials.append(_TokenFileCredential())
-        credentials.append(EnvironmentCredential())
-        if self.client_id:
-            credentials.append(ManagedIdentityCredential(client_id=self.client_id))
-        if self.authority and self.tenant_id:
-            credentials.append(VisualStudioCodeCredential(authority=self.authority, tenant_id=self.tenant_id))
-            credentials.append(AzureCliCredential(tenant_id=self.tenant_id))
-            credentials.append(AzurePowerShellCredential(tenant_id=self.tenant_id))
-            credentials.append(InteractiveBrowserCredential(authority=self.authority, tenant_id=self.tenant_id))
-            if self.client_id:
-                credentials.append(DeviceCodeCredential(authority=self.authority, client_id=self.client_id, tenant_id=self.tenant_id))
-        self.credentials = credentials
-
-    def get_token(self, *scopes: str, **kwargs) -> AccessToken:
-        """
-        Request an access token for `scopes`.
-        This method is called automatically by Azure SDK clients.
-        
-        :param str scopes: desired scopes for the access token.
-        This method requires at least one scope.
-        
-        :raises ~azure.core.exceptions.ClientAuthenticationError:authentication failed.
-            The exception has a `message` attribute listing each authentication
-            attempt and its error message.
-        """
-        # lazy-initialize the credentials
-        if self.credentials is None or len(self.credentials) == 0:
-            self._initialize_credentials()
-
-        return super(_DefaultAzureCredential, self).get_token(*scopes, **kwargs)
-
-    def _discover_tenant_id_(self, arm_endpoint:str, subscription_id:str):
-        """
-        If the tenant_id was not given, try to obtain it
-        by calling the management endpoint for the subscription_id,
-        or by applying default values.
-        """
-        if self.tenant_id:
-            return
-
-        try:
-            url = (
-                f"{arm_endpoint.rstrip('/')}/subscriptions/"
-                + f"{subscription_id}?api-version=2018-01-01"
-                + "&discover-tenant-id"  # used by the test recording infrastructure
-            )
-            http = urllib3.PoolManager()
-            response = http.request(
-                method="GET",
-                url=url,
-            )
-            if WWW_AUTHENTICATE_HEADER_NAME in response.headers:
-                www_authenticate = response.headers[WWW_AUTHENTICATE_HEADER_NAME]
-                match = re.search(WWW_AUTHENTICATE_REGEX, www_authenticate)
-                if match:
-                    self.tenant_id = match.group("tenant_id")
-        # pylint: disable=broad-exception-caught
-        except Exception as ex:
-            _LOGGER.error(ex)
-
-        # apply default values
-        self.tenant_id = self.tenant_id or ConnectionConstants.MSA_TENANT_ID

azure/quantum/_authentication/_token.py

@@ -1,83 +0,0 @@
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-import json
-from json.decoder import JSONDecodeError
-import logging
-import os
-import time
-
-from azure.identity import CredentialUnavailableError
-from azure.core.credentials import AccessToken
-from azure.quantum._constants import EnvironmentVariables
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class _TokenFileCredential(object):
-    """
-    Implements a custom TokenCredential to use a local file as
-    the source for an AzureQuantum token.
-
-    It will only use the local file if the AZURE_QUANTUM_TOKEN_FILE
-    environment variable is set, and references an existing json file
-    that contains the access_token and expires_on timestamp in milliseconds.
-
-    If the environment variable is not set, the file does not exist,
-    or the token is invalid in any way (expired, for example),
-    then the credential will throw CredentialUnavailableError,
-    so that _ChainedTokenCredential can fallback to other methods.
-    """
-    def __init__(self):
-        self.token_file = os.environ.get(EnvironmentVariables.QUANTUM_TOKEN_FILE)
-        if self.token_file:
-            _LOGGER.debug("Using provided token file location: %s", self.token_file)
-        else:
-            _LOGGER.debug("No token file location provided for %s environment variable.",
-                          EnvironmentVariables.QUANTUM_TOKEN_FILE)
-
-    def get_token(self, *scopes: str, **kwargs) -> AccessToken: # pylint:disable=unused-argument
-        """Request an access token for `scopes`.
-        This method is called automatically by Azure SDK clients.
-        This method only returns tokens for the https://quantum.microsoft.com/.default scope.
-        
-        :param str scopes: desired scopes for the access token.
-        
-        :raises ~azure.identity.CredentialUnavailableError 
-            when failing to get the token.
-            The exception has a `message` attribute with the error message.
-        """
-        if not self.token_file:
-            raise CredentialUnavailableError(message="Token file location not set.")
-
-        if not os.path.isfile(self.token_file):
-            raise CredentialUnavailableError(
-                message=f"Token file at {self.token_file} does not exist.")
-
-        try:
-            token = self._parse_token_file(self.token_file)
-        except JSONDecodeError as exception:
-            raise CredentialUnavailableError(
-                message="Failed to parse token file: Invalid JSON.") from exception
-        except KeyError as exception:
-            raise CredentialUnavailableError(
-                message="Failed to parse token file: Missing expected value: "
-                        + str(exception)) from exception
-        except Exception as exception:
-            raise CredentialUnavailableError(
-                message="Failed to parse token file: " + str(exception)) from exception
-
-        if token.expires_on <= time.time():
-            raise CredentialUnavailableError(
-                message=f"Token already expired at {time.asctime(time.gmtime(token.expires_on))}")
-
-        return token
-
-    def _parse_token_file(self, path) -> AccessToken:
-        with open(path, mode="r", encoding="utf-8") as file:
-            data = json.load(file)
-            # Convert ms to seconds, since python time.time only handles epoch time in seconds
-            expires_on = int(data["expires_on"]) / 1000
-            token = AccessToken(data["access_token"],  expires_on)
-            return token

azure/quantum/target/microsoft/elements/__init__.py

@@ -1 +0,0 @@
-"""Defines classes for interacting with Microsoft Elements services"""

azure/quantum/target/microsoft/elements/dft/__init__.py

@@ -1,6 +0,0 @@
-"""Defines classes for interacting with Microsoft Elements DFT service"""
-
-from .target import MicrosoftElementsDft
-from .job import MicrosoftElementsDftJob
-
-__all__ = ["MicrosoftElementsDft", "MicrosoftElementsDftJob"]

azure/quantum/target/microsoft/elements/dft/job.py

@@ -1,171 +0,0 @@
-import collections.abc
-import logging
-from typing import Any, Dict, Union, Optional
-from azure.quantum.job import JobFailedWithResultsError
-from azure.quantum.job.base_job import BaseJob, ContentType
-from azure.quantum.job.job import Job, DEFAULT_TIMEOUT
-from azure.quantum._client.models import JobDetails
-from azure.quantum.workspace import Workspace
-
-logger = logging.getLogger(__name__)
-
-class MicrosoftElementsDftJob(Job):
-    """
-    A dedicated job class for jobs from the microsoft.dft target.
-    """
-
-    def __init__(self, workspace, job_details: JobDetails, **kwargs):
-        """Azure Quantum Job that is submitted to a given Workspace.
-
-        :param workspace: Workspace instance to submit job to
-        :type workspace: Workspace
-        :param job_details: Job details model,
-                contains Job ID, name and other details
-        :type job_details: JobDetails
-        """
-        super().__init__(workspace, job_details, **kwargs)
-
-
-    def get_results(self, timeout_secs: float = DEFAULT_TIMEOUT) -> Dict[str, Any]:
-        """Get job results by downloading the results blob from the
-        storage container linked via the workspace.
-
-        :param timeout_secs: Timeout in seconds, defaults to 300
-        :type timeout_secs: float
-        :raises: :class:`RuntimeError` if job execution failed.
-        :raises: :class:`azure.quantum.job.JobFailedWithResultsError` if job execution failed,
-                but failure results could still be retrieved.
-        :return: Results dictionary.
-        """
-
-        try:
-            job_results = super().get_results(timeout_secs)
-            return job_results
-        except JobFailedWithResultsError as e:
-                failure_results = e.get_failure_results()
-                if MicrosoftElementsDftJob._is_dft_failure_results(failure_results):
-                    error = failure_results["results"][0]["error"]
-                    message = f'{e.get_message()} Error type: {error["error_type"]}. Message: {error["error_message"]}'
-                    raise JobFailedWithResultsError(message, failure_results) from None
-
-
-    @classmethod
-    def _allow_failure_results(cls) -> bool: 
-        """
-        Allow to download job results even if the Job status is "Failed".
-        """
-        return True
-
-
-    @staticmethod
-    def _is_dft_failure_results(failure_results: Union[Dict[str, Any], str]) -> bool:
-         return isinstance(failure_results, dict) \
-                    and "results" in failure_results \
-                    and isinstance(failure_results["results"], collections.abc.Sequence) \
-                    and len(failure_results["results"]) > 0 \
-                    and isinstance(failure_results["results"][0], dict) \
-                    and "error" in failure_results["results"][0] \
-                    and isinstance(failure_results["results"][0]["error"], dict) \
-                    and "error_type" in failure_results["results"][0]["error"] \
-                    and "error_message" in failure_results["results"][0]["error"]
-
-    @classmethod
-    def from_input_data_container(
-        cls,
-        workspace: "Workspace",
-        name: str,
-        target: str,
-        input_data: bytes,
-        batch_input_blobs: Dict[str, bytes],
-        content_type: ContentType = ContentType.json,
-        blob_name: str = "inputData",
-        encoding: str = "",
-        job_id: str = None,
-        container_name: str = None,
-        provider_id: str = None,
-        input_data_format: str = None,
-        output_data_format: str = None,
-        input_params: Dict[str, Any] = None,
-        session_id: Optional[str] = None,
-        **kwargs
-    ) -> "BaseJob":
-        """Create a new Azure Quantum job based on a list of input_data.
-
-        :param workspace: Azure Quantum workspace to submit the input_data to
-        :type workspace: Workspace
-        :param name: Name of the job
-        :type name: str
-        :param target: Azure Quantum target
-        :type target: str
-        :param input_data: Raw input data to submit
-        :type input_data: Dict
-        :param blob_name: Dict of Input data json to gives a table of contents
-        :type batch_input_blobs: Dict
-        :param blob_name: Dict of QcSchema Data where the key is the blob name to store it in the container
-        :type blob_name: str
-        :param content_type: Content type, e.g. "application/json"
-        :type content_type: ContentType
-        :param encoding: input_data encoding, e.g. "gzip", defaults to empty string
-        :type encoding: str
-        :param job_id: Job ID, defaults to None
-        :type job_id: str
-        :param container_name: Container name, defaults to None
-        :type container_name: str
-        :param provider_id: Provider ID, defaults to None
-        :type provider_id: str
-        :param input_data_format: Input data format, defaults to None
-        :type input_data_format: str
-        :param output_data_format: Output data format, defaults to None
-        :type output_data_format: str
-        :param input_params: Input parameters, defaults to None
-        :type input_params: Dict[str, Any]
-        :param input_params: Input params for job
-        :type input_params: Dict[str, Any]
-        :return: Azure Quantum Job
-        :rtype: Job
-        """
-        # Generate job ID if not specified
-        if job_id is None:
-            job_id = cls.create_job_id()
-
-        # Create container if it does not yet exist
-        container_uri = workspace.get_container_uri(
-            job_id=job_id,
-            container_name=container_name
-        )
-        logger.debug(f"Container URI: {container_uri}")
-
-        # Upload Input Data
-        input_data_uri = cls.upload_input_data(
-            container_uri=container_uri,
-            input_data=input_data,
-            content_type=content_type,
-            blob_name=blob_name,
-            encoding=encoding,
-        )
-
-        # Upload data to container
-        for blob_name, input_data_item in batch_input_blobs.items():
-            cls.upload_input_data(
-                container_uri=container_uri,
-                input_data=input_data_item,
-                content_type=content_type,
-                blob_name=blob_name,
-                encoding=encoding,
-            )
-
-        # Create and submit job
-        return cls.from_storage_uri(
-            workspace=workspace,
-            job_id=job_id,
-            target=target,
-            input_data_uri=input_data_uri,
-            container_uri=container_uri,
-            name=name,
-            input_data_format=input_data_format,
-            output_data_format=output_data_format,
-            provider_id=provider_id,
-            input_params=input_params,
-            session_id=session_id,
-            **kwargs
-        )