azure-quantum 0.29.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

azure/quantum/_client/aio/operations/_patch.py

@@ -1,20 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-"""Customize generated code here.
-
-Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
-"""
-from typing import List
-
-__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
-
-
-def patch_sdk():
-    """Do not remove from this file.
-
-    `patch_sdk` is a last resort escape hatch that allows you to do customizations
-    you can't accomplish using the techniques described in
-    https://aka.ms/azsdk/python/dpcodegen/python/customize
-    """

azure/quantum/aio/__init__.py

@@ -1,14 +0,0 @@
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-import logging
-from azure.quantum.version import __version__
-
-from .job.job import *
-from .workspace import *
-
-from azure.quantum._client.models._enums import JobStatus
-
-logger = logging.getLogger(__name__)
-logger.info(f"version: {__version__}")

azure/quantum/aio/_authentication/__init__.py

@@ -1,9 +0,0 @@
-# coding=utf-8
-##
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License.
-##
-
-from ._chained import *
-from ._default import _DefaultAzureCredential
-from ._token import _TokenFileCredential

azure/quantum/aio/_authentication/_chained.py

@@ -1,94 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-import logging
-from azure.core.exceptions import ClientAuthenticationError
-from azure.identity import CredentialUnavailableError
-from azure.identity import InteractiveBrowserCredential, DeviceCodeCredential
-
-from azure.quantum._authentication._chained import filter_credential_warnings, _get_error_message
-
-try:
-    from typing import TYPE_CHECKING
-except ImportError:
-    TYPE_CHECKING = False
-
-if TYPE_CHECKING:
-    # pylint:disable=unused-import,ungrouped-imports
-    from typing import Any, Optional
-    from azure.core.credentials_async import AccessToken, AsyncTokenCredential
-
-_LOGGER = logging.getLogger(__name__)
-
-import logging
-import sys
-
-
-class _ChainedTokenCredential(object):
-    """
-    Based on Azure.Identity.ChainedTokenCredential from:
-    https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/identity/azure-identity/azure/identity/_credentials/chained.py
-
-    The key difference is that we don't stop attempting all credentials
-    if some of then failed or raised an exception.
-    We also don't log a warning unless all credential attempts have failed.
-    """
-
-    def __init__(self, *credentials):
-        # type: (*AsyncTokenCredential) -> None
-        self._successful_credential = None  # type: Optional[AsyncTokenCredential]
-        self.credentials = credentials
-
-    async def get_token(self, *scopes, **kwargs):  # pylint:disable=unused-argument
-        # type: (*str, **Any) -> AccessToken
-        """Request a token from each chained credential, in order, returning the first token received.
-        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: no credential in the chain provided a token
-        """
-        history = []
-
-        # Suppress warnings from credentials in Azure.Identity
-        azure_identity_logger = logging.getLogger("azure.identity")
-        handler = logging.StreamHandler(stream=sys.stdout)
-        handler.addFilter(filter_credential_warnings)
-        azure_identity_logger.addHandler(handler)
-        try:
-            for credential in self.credentials:
-                try:
-                    if isinstance(credential, (InteractiveBrowserCredential, DeviceCodeCredential)):
-                        # InteractiveCredentials aren't async.
-                        token = credential.get_token(*scopes, **kwargs)
-                    else:
-                        token = await credential.get_token(*scopes, **kwargs)
-                    _LOGGER.info("%s acquired a token from %s", self.__class__.__name__, credential.__class__.__name__)
-                    self._successful_credential = credential
-                    return token
-                except CredentialUnavailableError as ex:
-                    # credential didn't attempt authentication because it lacks required data or state -> continue
-                    history.append((credential, ex.message))
-                    _LOGGER.info("%s - %s is unavailable", self.__class__.__name__, credential.__class__.__name__)
-                except Exception as ex:  # pylint: disable=broad-except
-                    # credential failed to authenticate, or something unexpectedly raised -> break
-                    history.append((credential, str(ex)))
-                    # instead of logging a warning, we just want to log an info
-                    # since other credentials might succeed
-                    _LOGGER.info(
-                        '%s.get_token failed: %s raised unexpected error "%s"',
-                        self.__class__.__name__,
-                        credential.__class__.__name__,
-                        ex,
-                        exc_info=_LOGGER.isEnabledFor(logging.DEBUG),
-                    )
-                    # here we do NOT want break and will continue to try other credentials
-
-        finally:
-            # Re-enable warnings from credentials in Azure.Identity
-            azure_identity_logger.removeHandler(handler)
-
-        # if all attempts failed, only then we log a warning and raise an error
-        attempts = _get_error_message(history)
-        message = self.__class__.__name__ + " failed to retrieve a token from the included credentials." + attempts
-        _LOGGER.warning(message)
-        raise ClientAuthenticationError(message=message)

azure/quantum/aio/_authentication/_default.py

@@ -1,212 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-import logging
-import os
-from azure.identity import InteractiveBrowserCredential, DeviceCodeCredential
-import requests
-import re
-
-from azure.identity._constants import EnvironmentVariables
-from azure.identity._internal import get_default_authority, normalize_authority
-from azure.identity.aio import (
-    AzurePowerShellCredential,
-    EnvironmentCredential,
-    ManagedIdentityCredential,
-    SharedTokenCacheCredential,
-    AzureCliCredential,
-    VisualStudioCodeCredential,
-)
-from ._chained import _ChainedTokenCredential
-from ._token import _TokenFileCredential
-
-try:
-    from typing import TYPE_CHECKING
-except ImportError:
-    TYPE_CHECKING = False
-
-if TYPE_CHECKING:
-    from typing import Any, List
-    from azure.core.credentials_async import AccessToken, AsyncTokenCredential
-
-_LOGGER = logging.getLogger(__name__)
-
-
-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 two 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_base_url (defaults to the production url "https://management.azure.com/")
-    """
-    def __init__(self, **kwargs):
-        # type: (**Any) -> None
-        self._successfull_tenant_id = None
-
-        self.authority = kwargs.pop("authority", None)
-        self.authority = normalize_authority(self.authority) if self.authority else get_default_authority()
-
-        self.interactive_browser_tenant_id = kwargs.pop(
-            "interactive_browser_tenant_id", os.environ.get(EnvironmentVariables.AZURE_TENANT_ID)
-        )
-
-        self.subscription_id = kwargs.pop(
-            "subscription_id", os.environ.get("SUBSCRIPTION_ID")
-        )
-        self.arm_base_url = kwargs.pop(
-            "arm_base_url", "https://management.azure.com/"
-        )
-
-        self.managed_identity_client_id = kwargs.pop(
-            "managed_identity_client_id", os.environ.get(EnvironmentVariables.AZURE_CLIENT_ID)
-        )
-
-        self.shared_cache_username = kwargs.pop("shared_cache_username", os.environ.get(EnvironmentVariables.AZURE_USERNAME))
-        self.shared_cache_tenant_id = kwargs.pop(
-            "shared_cache_tenant_id", os.environ.get(EnvironmentVariables.AZURE_TENANT_ID)
-        )
-
-        self.vscode_tenant_id = kwargs.pop(
-            "visual_studio_code_tenant_id", os.environ.get(EnvironmentVariables.AZURE_TENANT_ID)
-        )
-
-        self.exclude_token_file_credential = kwargs.pop("exclude_token_file_credential", False)
-        self.exclude_environment_credential = kwargs.pop("exclude_environment_credential", False)
-        self.exclude_managed_identity_credential = kwargs.pop("exclude_managed_identity_credential", False)
-        self.exclude_shared_token_cache_credential = kwargs.pop("exclude_shared_token_cache_credential", False)
-        self.exclude_visual_studio_code_credential = kwargs.pop("exclude_visual_studio_code_credential", False)
-        self.exclude_cli_credential = kwargs.pop("exclude_cli_credential", False)
-        self.exclude_interactive_browser_credential = kwargs.pop("exclude_interactive_browser_credential", True)
-        self.exclude_device_code_credential = kwargs.pop("exclude_device_code_credential", False)
-        self.exclude_powershell_credential = kwargs.pop("exclude_powershell_credential", False)
-
-        # credentials will be created lazy on the first call to get_token
-        super(_DefaultAzureCredential, self).__init__()
-
-    def _initialize_credentials(self):
-        if self.subscription_id is not None \
-           and self.arm_base_url is not None:
-            if self.vscode_tenant_id is None:
-                self.vscode_tenant_id = self._get_tenant_id(arm_base_url=self.arm_base_url, subscription_id=self.subscription_id)
-            if self.shared_cache_tenant_id is None:
-                self.shared_cache_tenant_id = self._get_tenant_id(arm_base_url=self.arm_base_url, subscription_id=self.subscription_id)
-            if self.interactive_browser_tenant_id is None:
-                self.interactive_browser_tenant_id = self._get_tenant_id(arm_base_url=self.arm_base_url, subscription_id=self.subscription_id)
-
-        credentials = []  # type: List[AsyncTokenCredential]
-        if not self.exclude_token_file_credential:
-            credentials.append(_TokenFileCredential())
-        if not self.exclude_environment_credential:
-            credentials.append(EnvironmentCredential(authority=self.authority))
-        if not self.exclude_managed_identity_credential:
-            credentials.append(ManagedIdentityCredential(client_id=self.managed_identity_client_id))
-        if not self.exclude_shared_token_cache_credential and SharedTokenCacheCredential.supported():
-            try:
-                # username and/or tenant_id are only required when the cache contains tokens for multiple identities
-                shared_cache = SharedTokenCacheCredential(
-                    username=self.shared_cache_username, tenant_id=self.shared_cache_tenant_id, authority=self.authority
-                )
-                credentials.append(shared_cache)
-            except Exception as ex:  # pylint:disable=broad-except
-                _LOGGER.info("Shared token cache is unavailable: '%s'", ex)
-        if not self.exclude_visual_studio_code_credential:
-            credentials.append(VisualStudioCodeCredential(tenant_id=self.vscode_tenant_id))
-        if not self.exclude_cli_credential:
-            credentials.append(AzureCliCredential())
-        if not self.exclude_powershell_credential:
-            credentials.append(AzurePowerShellCredential())
-        if not self.exclude_interactive_browser_credential:
-            credentials.append(InteractiveBrowserCredential(tenant_id=self.interactive_browser_tenant_id))
-        if not self.exclude_device_code_credential:
-            credentials.append(DeviceCodeCredential(tenant_id=self.interactive_browser_tenant_id))
-
-        self.credentials = credentials
-
-    async def get_token(self, *scopes, **kwargs):
-        # type: (*str, **Any) -> 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.
-        """
-        # add credentials the first time it runs the get_token
-        # such that the _get_tenant_id can be called only when needed
-        if self.credentials is None \
-           or len(self.credentials) == 0:
-            self._initialize_credentials()
-
-        return await super(_DefaultAzureCredential, self).get_token(*scopes, **kwargs)
-
-    def _get_tenant_id(self, arm_base_url:str, subscription_id:str):
-        if arm_base_url is None:
-            raise ValueError("arm_base_url is mandatory parameter")
-        if subscription_id is None:
-            raise ValueError("subscription_id is mandatory parameter")
-
-        # returns the cached tenant_id if available
-        if self._successfull_tenant_id is not None:
-            return self._successfull_tenant_id
-
-        try:
-            uri = (
-                f"{arm_base_url}/subscriptions/"
-                + f"{subscription_id}?api-version=2018-01-01"
-            )
-            response = requests.get(uri)
-
-            # This gnarly piece of code is how we get the guest tenant
-            # authority associated with the subscription.
-            # We make a unauthenticated request to ARM and extract the tenant
-            # authority from the WWW-Authenticate header in the response.
-            # The header is of the form:
-            # Bearer authorization_uri=
-            # https://login.microsoftonline.com/tenantId, key1=value1s
-            auth_header = response.headers["WWW-Authenticate"]
-            _LOGGER.debug(
-                f'{"got the following auth header from"}'
-                f"the management endpoint: {auth_header}"
-            )
-
-            trimmed_auth_header = auth_header[
-                len("Bearer "):
-            ]  # trim the leading 'Bearer '
-            trimmed_auth_header_parts = trimmed_auth_header.split(
-                ","
-            )  # get the various k=v parts
-            key_value_pairs = dict(
-                map(lambda s: tuple(s.split("=")), trimmed_auth_header_parts)
-            )  # make the parts into a dictionary
-            quoted_tenant_uri = key_value_pairs[
-                "authorization_uri"
-            ]  # get the value of the 'authorization_uri' key
-            tenant_uri = quoted_tenant_uri[
-                1:-1
-            ]  # strip it of surrounding quotes
-
-            _LOGGER.debug(
-                f'{"got the following tenant uri from"}'
-                + f"the authentication header: {tenant_uri}"
-            )
-
-            regex = re.compile(pattern=r"([a-f0-9]+[-]){4}[a-f0-9]+", flags=re.IGNORECASE)
-            self._successfull_tenant_id = regex.search(tenant_uri).group()
-            return self._successfull_tenant_id
-
-        except Exception as e:
-            _LOGGER.debug(
-                f"Failed to get tenant authority for subscription: {e}"
-            )
-            return None

azure/quantum/aio/_authentication/_token.py

@@ -1,81 +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 aiofile import async_open
-
-from azure.identity import CredentialUnavailableError
-from azure.core.credentials import AccessToken
-
-try:
-    from typing import TYPE_CHECKING
-except ImportError:
-    TYPE_CHECKING = False
-
-if TYPE_CHECKING:
-    # pylint:disable=unused-import,ungrouped-imports
-    from typing import Any
-
-_LOGGER = logging.getLogger(__name__)
-
-_TOKEN_FILE_ENV_VARIABLE = "AZURE_QUANTUM_TOKEN_FILE"
-
-
-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, **kwargs):
-        # type: (**Any) -> None
-        self.token_file = os.environ.get(_TOKEN_FILE_ENV_VARIABLE)
-        if self.token_file:
-            _LOGGER.debug("Using provided token file location: {}".format(self.token_file))
-        else:
-            _LOGGER.debug("No token file location provided for {} environment variable.".format(_TOKEN_FILE_ENV_VARIABLE))
-
-    async def get_token(self, *scopes, **kwargs):  # pylint:disable=unused-argument
-        # type: (*str, **Any) -> 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 only returns tokens for the https://quantum.microsoft.com/.default scope.
-        :raises ~azure.identity.CredentialUnavailableError: when failing to get 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="Token file at {} does not exist.".format(self.token_file))
-
-        try:
-            token = await self._parse_token_file(self.token_file)
-        except JSONDecodeError:
-            raise CredentialUnavailableError(message="Failed to parse token file: Invalid JSON.")
-        except KeyError as e:
-            raise CredentialUnavailableError(message="Failed to parse token file: Missing expected value: " + str(e))
-        except Exception as e:
-            raise CredentialUnavailableError(message="Failed to parse token file: " + str(e))
-
-        if token.expires_on <= time.time():
-            raise CredentialUnavailableError(message="Token already expired at {}".format(time.asctime(time.gmtime(token.expires_on))))
-
-        return token
-
-    async def _parse_token_file(self, path):
-        # type: (*str) -> AccessToken
-        async with async_open(path, "r") as file:
-            data = json.load(file)
-            expires_on = int(data["expires_on"]) / 1000  # Convert ms to seconds, since python time.time only handles epoch time in seconds
-            token = AccessToken(data["access_token"],  expires_on)
-            return token

azure/quantum/aio/job/__init__.py

@@ -1 +0,0 @@
-from azure.quantum.aio.job.job import Job