Metadata-Version: 2.1
Name: azure-identity
Version: 1.4.0b4
Summary: Microsoft Azure Identity Library for Python
Home-page: https://github.com/Azure/azure-sdk-for-python/tree/master/sdk/identity/azure-identity
Author: Microsoft Corporation
Author-email: azpysdkhelp@microsoft.com
License: MIT License
Description: # Azure Identity client library for Python
        Azure Identity authenticating with Azure Active Directory for Azure SDK
        libraries. It provides credentials Azure SDK clients can use to authenticate
        their requests.
        
        This library currently supports:
          - [Service principal authentication](https://docs.microsoft.com/en-us/azure/active-directory/develop/app-objects-and-service-principals)
          - [Managed identity authentication](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/overview)
          - User authentication
        
          [Source code](https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/identity/azure-identity)
          | [Package (PyPI)](https://pypi.org/project/azure-identity/)
          | [API reference documentation][ref_docs]
          | [Azure Active Directory documentation](https://docs.microsoft.com/en-us/azure/active-directory/)
        
        # Getting started
        ## Prerequisites
        - an [Azure subscription](https://azure.microsoft.com/free/)
        - Python 2.7 or 3.5.3+
        
        ## Install the package
        Install Azure Identity with pip:
        ```sh
        pip install azure-identity
        ```
        
        #### Creating a Service Principal with the Azure CLI
        This library doesn't require a service principal, but Azure applications
        commonly use them for authentication. If you need to create one, you can use
        this [Azure CLI](https://docs.microsoft.com/cli/azure) snippet. Before using
        it, replace "http://my-application" with a more appropriate name for your
        service principal.
        
        Create a service principal:
        ```sh
        az ad sp create-for-rbac --name http://my-application --skip-assignment
        ```
        
        Example output:
        ```json
        {
            "appId": "generated-app-id",
            "displayName": "app-name",
            "name": "http://my-application",
            "password": "random-password",
            "tenant": "tenant-id"
        }
        ```
        Azure Identity can authenticate as this service principal using its tenant id
        ("tenant" above), client id ("appId" above), and client secret ("password" above).
        
        
        # Key concepts
        ## Credentials
        A credential is a class which contains or can obtain the data needed for a
        service client to authenticate requests. Service clients across the Azure SDK
        accept credentials as constructor parameters, as described in their
        documentation. The [next steps](#client-library-support) section below contains
        a partial list of client libraries accepting Azure Identity credentials.
        
        Credential classes are found in the `azure.identity` namespace. They differ
        in the types of identities they can authenticate as, and in their configuration:
        
        |credential class|identity|configuration
        |-|-|-
        |[DefaultAzureCredential](#defaultazurecredential "DefaultAzureCredential")|service principal, managed identity, user|none for managed identity, [environment variables](#environment-variables "environment variables") for service principal or user authentication
        |[ManagedIdentityCredential][managed_id_cred_ref]|managed identity|none
        |[EnvironmentCredential][environment_cred_ref]|service principal, user|[environment variables](#environment-variables "environment variables")
        |[ClientSecretCredential][client_secret_cred_ref]|service principal|constructor parameters
        |[CertificateCredential][cert_cred_ref]|service principal|constructor parameters
        |[DeviceCodeCredential][device_code_cred_ref]|user|constructor parameters
        |[InteractiveBrowserCredential][interactive_cred_ref]|user|constructor parameters
        |[UsernamePasswordCredential][userpass_cred_ref]|user|constructor parameters
        
        Credentials can be chained together and tried in turn until one succeeds; see
        [chaining credentials](#chaining-credentials "chaining credentials") for details.
        
        Service principal and managed identity credentials have async equivalents in
        the [azure.identity.aio][ref_docs_aio] namespace, supported on Python 3.5.3+.
        See the [async credentials](#async-credentials "async credentials") example for
        details. Async user credentials will be part of a future release.
        
        ## DefaultAzureCredential
        [DefaultAzureCredential][default_cred_ref] is appropriate for most
        applications intended to run in Azure. It can authenticate as a service
        principal, managed identity, or user, and can be configured for local
        development and production environments without code changes.
        
        To authenticate as a service principal, provide configuration in
        [environment variables](#environment-variables "environment variables") as
        described in the next section.
        
        Authenticating as a managed identity requires no configuration but is only
        possible in a supported hosting environment. See Azure Active Directory's
        [managed identity documentation](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/services-support-managed-identities)
        for more information.
        
        #### Single sign-on
        During local development on Windows, [DefaultAzureCredential][default_cred_ref]
        can authenticate using a single sign-on shared with Microsoft applications, for
        example Visual Studio 2019. This may require additional configuration when
        multiple identities have signed in. In that case, set the environment variables
        `AZURE_USERNAME` (typically an email address) and `AZURE_TENANT_ID` to select
        the desired identity. Either, or both, may be set.
        
        ## Environment variables
        [DefaultAzureCredential][default_cred_ref] and
        [EnvironmentCredential][environment_cred_ref] can be configured with
        environment variables. Each type of authentication requires values for specific
        variables:
        
        #### Service principal with secret
        >|variable name|value
        >|-|-
        >|`AZURE_CLIENT_ID`|id of an Azure Active Directory application
        >|`AZURE_TENANT_ID`|id of the application's Azure Active Directory tenant
        >|`AZURE_CLIENT_SECRET`|one of the application's client secrets
        
        #### Service principal with certificate
        >|variable name|value
        >|-|-
        >|`AZURE_CLIENT_ID`|id of an Azure Active Directory application
        >|`AZURE_TENANT_ID`|id of the application's Azure Active Directory tenant
        >|`AZURE_CLIENT_CERTIFICATE_PATH`|path to a PEM-encoded certificate file including private key (without password protection)
        
        #### Username and password
        >|variable name|value
        >|-|-
        >|`AZURE_CLIENT_ID`|id of an Azure Active Directory application
        >|`AZURE_USERNAME`|a username (usually an email address)
        >|`AZURE_PASSWORD`|that user's password
        
        > Note: username/password authentication is not supported by the async API
        ([azure.identity.aio][ref_docs_aio])
        
        Configuration is attempted in the above order. For example, if values for a
        client secret and certificate are both present, the client secret will be used.
        
        # Examples
        ## Authenticating with `DefaultAzureCredential`
        This example demonstrates authenticating the `BlobServiceClient` from the
        [azure-storage-blob][azure_storage_blob] library using
        [DefaultAzureCredential](#defaultazurecredential "DefaultAzureCredential").
        
        ```py
        from azure.identity import DefaultAzureCredential
        from azure.storage.blob import BlobServiceClient
        
        # This credential first checks environment variables for configuration as described above.
        # If environment configuration is incomplete, it will try managed identity.
        credential = DefaultAzureCredential()
        
        client = BlobServiceClient(account_url, credential=credential)
        ```
        
        ## Authenticating a service principal with a client secret:
        This example demonstrates authenticating the `KeyClient` from the
        [azure-keyvault-keys][azure_keyvault_keys] library using
        [ClientSecretCredential][client_secret_cred_ref].
        
        ```py
        from azure.identity import ClientSecretCredential
        from azure.keyvault.keys import KeyClient
        
        credential = ClientSecretCredential(tenant_id, client_id, client_secret)
        
        client = KeyClient("https://my-vault.vault.azure.net", credential)
        ```
        
        ## Authenticating a service principal with a certificate:
        This example demonstrates authenticating the `SecretClient` from the
        [azure-keyvault-secrets][azure_keyvault_secrets] library using
        [CertificateCredential][cert_cred_ref].
        
        ```py
        from azure.identity import CertificateCredential
        from azure.keyvault.secrets import SecretClient
        
        # requires a PEM-encoded certificate with private key
        cert_path = "/app/certs/certificate.pem"
        credential = CertificateCredential(tenant_id, client_id, cert_path)
        
        # if the private key is password protected, provide a 'password' keyword argument
        credential = CertificateCredential(tenant_id, client_id, cert_path, password="cert-password")
        
        
        client = SecretClient("https://my-vault.vault.azure.net", credential)
        ```
        
        ## Chaining credentials
        [ChainedTokenCredential][chain_cred_ref] links multiple credential instances
        to be tried sequentially when authenticating. It will try each chained
        credential in turn until one provides a token or fails to authenticate due to
        an error.
        
        The following example demonstrates creating a credential which will attempt to
        authenticate using managed identity, and fall back to a service principal when
        managed identity is unavailable. This example uses the `EventHubClient` from
        the [azure-eventhub][azure_eventhub] client library.
        
        ```py
        from azure.eventhub import EventHubClient
        from azure.identity import ChainedTokenCredential, ClientSecretCredential, ManagedIdentityCredential
        
        managed_identity = ManagedIdentityCredential()
        service_principal = ClientSecretCredential(tenant_id, client_id, client_secret)
        
        # when an access token is needed, the chain will try each credential in order,
        # stopping when one provides a token or fails to authenticate due to an error
        credential_chain = ChainedTokenCredential(managed_identity, service_principal)
        
        # the ChainedTokenCredential can be used anywhere a credential is required
        client = EventHubClient(host, event_hub_path, credential_chain)
        ```
        
        ## Async credentials:
        This library includes an async API supported on Python 3.5+. To use the async
        credentials in [azure.identity.aio][ref_docs_aio], you must first install an
        async transport, such as [aiohttp](https://pypi.org/project/aiohttp/). See
        [azure-core documentation](https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/core/azure-core/README.md#transport)
        for more information.
        
        Async credentials should be closed when they're no longer needed. Each async
        credential is an async context manager and defines an async `close` method. For
        example:
        
        ```py
        from azure.identity.aio import DefaultAzureCredential
        
        # call close when the credential is no longer needed
        credential = DefaultAzureCredential()
        ...
        await credential.close()
        
        # alternatively, use the credential as an async context manager
        credential = DefaultAzureCredential()
        async with credential:
          ...
        ```
        
        This example demonstrates authenticating the asynchronous `SecretClient` from
        [azure-keyvault-secrets][azure_keyvault_secrets] with an asynchronous
        credential.
        
        ```py
        # most credentials have async equivalents supported on Python 3.5.3+
        from azure.identity.aio import DefaultAzureCredential
        from azure.keyvault.secrets.aio import SecretClient
        
        # async credentials have the same API and configuration as their synchronous
        # counterparts, and are used with (async) Azure SDK clients in the same way
        default_credential = DefaultAzureCredential()
        client = SecretClient("https://my-vault.vault.azure.net", default_credential)
        ```
        
        # Troubleshooting
        ## General
        Credentials raise `CredentialUnavailableError` when they're unable to attempt
        authentication because they lack required data or state. For example,
        [EnvironmentCredential][environment_cred_ref] will raise this exception when
        [its configuration](#environment-variables "its configuration") is incomplete.
        
        Credentials raise `azure.core.exceptions.ClientAuthenticationError` when they fail
        to authenticate. `ClientAuthenticationError` has a `message` attribute which
        describes why authentication failed. When raised by
        [DefaultAzureCredential](#defaultazurecredential) or `ChainedTokenCredential`,
        the message collects error messages from each credential in the chain.
        
        For more details on handling Azure Active Directory errors please refer to the
        Azure Active Directory
        [error code documentation](https://docs.microsoft.com/en-us/azure/active-directory/develop/reference-aadsts-error-codes).
        
        
        # Next steps
        ## Client library support
        This is an incomplete list of client libraries accepting Azure Identity
        credentials. You can learn more about these libraries, and find additional
        documentation of them, at the links below.
        - [azure-appconfiguration](https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/appconfiguration/azure-appconfiguration)
        - [azure-eventhub][azure_eventhub]
        - [azure-keyvault-certificates](https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/keyvault/azure-keyvault-certificates)
        - [azure-keyvault-keys][azure_keyvault_keys]
        - [azure-keyvault-secrets][azure_keyvault_secrets]
        - [azure-storage-blob][azure_storage_blob]
        - [azure-storage-queue](https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/storage/azure-storage-queue)
        
        ## Provide Feedback
        If you encounter bugs or have suggestions, please
        [open an issue](https://github.com/Azure/azure-sdk-for-python/issues).
        
        
        # Contributing
        This project welcomes contributions and suggestions. Most contributions require
        you to agree to a Contributor License Agreement (CLA) declaring that you have
        the right to, and actually do, grant us the rights to use your contribution.
        For details, visit [https://cla.microsoft.com](https://cla.microsoft.com).
        
        When you submit a pull request, a CLA-bot will automatically determine whether
        you need to provide a CLA and decorate the PR appropriately (e.g., label,
        comment). Simply follow the instructions provided by the bot. You will only
        need to do this once across all repos using our CLA.
        
        This project has adopted the
        [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
        For more information, see the
        [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
        or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any
        additional questions or comments.
        
        [azure_eventhub]: https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/eventhub/azure-eventhub
        [azure_keyvault_keys]: https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/keyvault/azure-keyvault-keys
        [azure_keyvault_secrets]: https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/keyvault/azure-keyvault-secrets
        [azure_storage_blob]: https://github.com/Azure/azure-sdk-for-python/tree/3c2cd50d181aa2f47a865135d29a646f3ace4102/sdk/storage/azure-storage-blob
        
        [ref_docs]: https://aka.ms/azsdk-python-identity-docs
        [ref_docs_aio]: https://aka.ms/azsdk-python-identity-aio-docs
        [cert_cred_ref]: https://aka.ms/azsdk-python-identity-cert-cred-ref
        [chain_cred_ref]: https://aka.ms/azsdk-python-identity-chain-cred-ref
        [client_secret_cred_ref]: https://aka.ms/azsdk-python-identity-client-secret-cred-ref
        [client_secret_cred_aio_ref]: https://aka.ms/azsdk-python-identity-client-secret-cred-aio-ref
        [default_cred_ref]: https://aka.ms/azsdk-python-identity-default-cred-ref
        [device_code_cred_ref]: https://aka.ms/azsdk-python-identity-device-code-cred-ref
        [environment_cred_ref]: https://aka.ms/azsdk-python-identity-environment-cred-ref
        [interactive_cred_ref]: https://aka.ms/azsdk-python-identity-interactive-cred-ref
        [managed_id_cred_ref]: https://aka.ms/azsdk-python-identity-managed-id-cred-ref
        [userpass_cred_ref]: https://aka.ms/azsdk-python-identity-userpass-cred-ref
        
        ![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-python%2Fsdk%2Fidentity%2Fazure-identity%2FREADME.png)
        
        
        # Release History
        
        ## 1.4.0b4 (2020-06-09)
        - `ManagedIdentityCredential` can configure a user-assigned identity using any
          identifier supported by the current hosting environment. To specify an
          identity by its client ID, continue using the `client_id` argument. To
          specify an identity by any other ID, use the `identity_config` argument,
          for example: `ManagedIdentityCredential(identity_config={"object_id": ".."})`
          ([#10989](https://github.com/Azure/azure-sdk-for-python/issues/10989)) 
        - `CertificateCredential` and `ClientSecretCredential` can optionally store
          access tokens they acquire in a persistent cache. To enable this, construct
          the credential with `enable_persistent_cache=True`. On Linux, the persistent
          cache requires libsecret and `pygobject`. If these are unavailable or
          unusable (e.g. in an SSH session), loading the persistent cache will raise an
          error. You may optionally configure the credential to fall back to an
          unencrypted cache by constructing it with keyword argument 
          `allow_unencrypted_cache=True`.
          ([#11347](https://github.com/Azure/azure-sdk-for-python/issues/11347))
        - `AzureCliCredential` raises `CredentialUnavailableError` when no user is
          logged in to the Azure CLI.
          ([#11819](https://github.com/Azure/azure-sdk-for-python/issues/11819))
        - `AzureCliCredential` and `VSCodeCredential`, which enable authenticating as
          the identity signed in to the Azure CLI and Visual Studio Code, respectively,
          can be imported from `azure.identity` and `azure.identity.aio`.
        - `azure.identity.aio.AuthorizationCodeCredential.get_token()` no longer accepts
          optional keyword arguments `executor` or `loop`. Prior versions of the method
          didn't use these correctly, provoking exceptions, and internal changes in this
          version have made them obsolete.
        - `InteractiveBrowserCredential` raises `CredentialUnavailableError` when it
          can't start an HTTP server on `localhost`.
          ([#11665](https://github.com/Azure/azure-sdk-for-python/pull/11665))
        - When constructing `DefaultAzureCredential`, you can now configure a tenant ID
          for `InteractiveBrowserCredential`. When none is specified, the credential
          authenticates users in their home tenants. To specify a different tenant, use
          the keyword argument `interactive_browser_tenant_id`, or set the environment
          variable `AZURE_TENANT_ID`.
          ([#11548](https://github.com/Azure/azure-sdk-for-python/issues/11548))
        - `SharedTokenCacheCredential` can be initialized with an `AuthenticationRecord`
          provided by a user credential.
          ([#11448](https://github.com/Azure/azure-sdk-for-python/issues/11448))
        - The user authentication API added to `DeviceCodeCredential` and
          `InteractiveBrowserCredential` in 1.4.0b3 is available on
          `UsernamePasswordCredential` as well.
          ([#11449](https://github.com/Azure/azure-sdk-for-python/issues/11449))
        - The optional persistent cache for `DeviceCodeCredential` and
          `InteractiveBrowserCredential` added in 1.4.0b3 is now available on Linux and
          macOS as well as Windows.
          ([#11134](https://github.com/Azure/azure-sdk-for-python/issues/11134))
          - On Linux, the persistent cache requires libsecret and `pygobject`. If these
            are unavailable, or libsecret is unusable (e.g. in an SSH session), loading
            the persistent cache will raise an error. You may optionally configure the
            credential to fall back to an unencrypted cache by constructing it with
            keyword argument `allow_unencrypted_cache=True`.
        
        ## 1.4.0b3 (2020-05-04)
        - `EnvironmentCredential` correctly initializes `UsernamePasswordCredential`
        with the value of `AZURE_TENANT_ID` 
        ([#11127](https://github.com/Azure/azure-sdk-for-python/pull/11127))
        - Values for the constructor keyword argument `authority` and
        `AZURE_AUTHORITY_HOST` may optionally specify an "https" scheme. For example,
        "https://login.microsoftonline.us" and "login.microsoftonline.us" are both valid.
        ([#10819](https://github.com/Azure/azure-sdk-for-python/issues/10819))
        - First preview of new API for authenticating users with `DeviceCodeCredential`
          and `InteractiveBrowserCredential`
          ([#10612](https://github.com/Azure/azure-sdk-for-python/pull/10612))
          - new method `authenticate` interactively authenticates a user, returns a
            serializable `AuthenticationRecord`
          - new constructor keyword arguments
            - `authentication_record` enables initializing a credential with an
              `AuthenticationRecord` from a prior authentication
            - `disable_automatic_authentication=True` configures the credential to raise
            `AuthenticationRequiredError` when interactive authentication is necessary
            to acquire a token rather than immediately begin that authentication
            - `enable_persistent_cache=True` configures these credentials to use a
            persistent cache on supported platforms (in this release, Windows only).
            By default they cache in memory only.
        - Now `DefaultAzureCredential` can authenticate with the identity signed in to 
        Visual Studio Code's Azure extension.
        ([#10472](https://github.com/Azure/azure-sdk-for-python/issues/10472))
        
        ## 1.4.0b2 (2020-04-06)
        - After an instance of `DefaultAzureCredential` successfully authenticates, it
        uses the same authentication method for every subsequent token request. This
        makes subsequent requests more efficient, and prevents unexpected changes of
        authentication method.
        ([#10349](https://github.com/Azure/azure-sdk-for-python/pull/10349))
        - All `get_token` methods consistently require at least one scope argument,
        raising an error when none is passed. Although `get_token()` may sometimes
        have succeeded in prior versions, it couldn't do so consistently because its
        behavior was undefined, and dependened on the credential's type and internal
        state. ([#10243](https://github.com/Azure/azure-sdk-for-python/issues/10243))
        - `SharedTokenCacheCredential` raises `CredentialUnavailableError` when the
        cache is available but contains ambiguous or insufficient information. This
        causes `ChainedTokenCredential` to correctly try the next credential in the
        chain. ([#10631](https://github.com/Azure/azure-sdk-for-python/issues/10631))
        - The host of the Active Directory endpoint credentials should use can be set
        in the environment variable `AZURE_AUTHORITY_HOST`. See
        `azure.identity.KnownAuthorities` for a list of common values.
        ([#8094](https://github.com/Azure/azure-sdk-for-python/issues/8094))
        
        
        ## 1.3.1 (2020-03-30)
        
        - `ManagedIdentityCredential` raises `CredentialUnavailableError` when no
        identity is configured for an IMDS endpoint. This causes
        `ChainedTokenCredential` to correctly try the next credential in the chain.
        ([#10488](https://github.com/Azure/azure-sdk-for-python/issues/10488))
        
        
        ## 1.4.0b1 (2020-03-10)
        - `DefaultAzureCredential` can now authenticate using the identity logged in to
        the Azure CLI, unless explicitly disabled with a keyword argument:
        `DefaultAzureCredential(exclude_cli_credential=True)`
        ([#10092](https://github.com/Azure/azure-sdk-for-python/pull/10092))
        
        
        ## 1.3.0 (2020-02-11)
        
        - Correctly parse token expiration time on Windows App Service
        ([#9393](https://github.com/Azure/azure-sdk-for-python/issues/9393))
        - Credentials raise `CredentialUnavailableError` when they can't attempt to
        authenticate due to missing data or state
        ([#9372](https://github.com/Azure/azure-sdk-for-python/pull/9372))
        - `CertificateCredential` supports password-protected private keys
        ([#9434](https://github.com/Azure/azure-sdk-for-python/pull/9434))
        
        
        ## 1.2.0 (2020-01-14)
        
        - All credential pipelines include `ProxyPolicy`
        ([#8945](https://github.com/Azure/azure-sdk-for-python/pull/8945))
        - Async credentials are async context managers and have an async `close` method
        ([#9090](https://github.com/Azure/azure-sdk-for-python/pull/9090))
        
        
        ## 1.1.0 (2019-11-27)
        
        - Constructing `DefaultAzureCredential` no longer raises `ImportError` on Python
        3.8 on Windows ([8294](https://github.com/Azure/azure-sdk-for-python/pull/8294))
        - `InteractiveBrowserCredential` raises when unable to open a web browser
        ([8465](https://github.com/Azure/azure-sdk-for-python/pull/8465))
        - `InteractiveBrowserCredential` prompts for account selection
        ([8470](https://github.com/Azure/azure-sdk-for-python/pull/8470))
        - The credentials composing `DefaultAzureCredential` are configurable by keyword
        arguments ([8514](https://github.com/Azure/azure-sdk-for-python/pull/8514))
        - `SharedTokenCacheCredential` accepts an optional `tenant_id` keyword argument
        ([8689](https://github.com/Azure/azure-sdk-for-python/pull/8689))
        
        
        ## 1.0.1 (2019-11-05)
        
        - `ClientCertificateCredential` uses application and tenant IDs correctly
        ([8315](https://github.com/Azure/azure-sdk-for-python/pull/8315))
        - `InteractiveBrowserCredential` properly caches tokens
        ([8352](https://github.com/Azure/azure-sdk-for-python/pull/8352))
        - Adopted msal 1.0.0 and msal-extensions 0.1.3
        ([8359](https://github.com/Azure/azure-sdk-for-python/pull/8359))
        
        
        ## 1.0.0 (2019-10-29)
        ### Breaking changes:
        - Async credentials now default to [`aiohttp`](https://pypi.org/project/aiohttp/)
        for transport but the library does not require it as a dependency because the
        async API is optional. To use async credentials, please install
        [`aiohttp`](https://pypi.org/project/aiohttp/) or see
        [azure-core documentation](https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/core/azure-core/README.md#transport)
        for information about customizing the transport.
        - Renamed `ClientSecretCredential` parameter "`secret`" to "`client_secret`"
        - All credentials with `tenant_id` and `client_id` positional parameters now accept them in that order
        - Changes to `InteractiveBrowserCredential` parameters
          - positional parameter `client_id` is now an optional keyword argument. If no value is provided,
        the Azure CLI's client ID will be used.
          - Optional keyword argument `tenant` renamed `tenant_id`
        - Changes to `DeviceCodeCredential`
          - optional positional parameter `prompt_callback` is now a keyword argument
          - `prompt_callback`'s third argument is now a `datetime` representing the
          expiration time of the device code
          - optional keyword argument `tenant` renamed `tenant_id`
        - Changes to `ManagedIdentityCredential`
          - now accepts no positional arguments, and only one keyword argument:
          `client_id`
          - transport configuration is now done through keyword arguments as
          described in
          [`azure-core` documentation](https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/core/azure-core/docs/configuration.md)
        
        ### Fixes and improvements:
        - Authenticating with a single sign-on shared with other Microsoft applications
        only requires a username when multiple users have signed in
        ([#8095](https://github.com/Azure/azure-sdk-for-python/pull/8095))
        - `DefaultAzureCredential` accepts an `authority` keyword argument, enabling
        its use in national clouds
        ([#8154](https://github.com/Azure/azure-sdk-for-python/pull/8154))
        
        ### Dependency changes
        - Adopted [`msal_extensions`](https://pypi.org/project/msal-extensions/) 0.1.2
        - Constrained [`msal`](https://pypi.org/project/msal/) requirement to >=0.4.1,
        <1.0.0
        
        
        ## 1.0.0b4 (2019-10-07)
        ### New features:
        - `AuthorizationCodeCredential` authenticates with a previously obtained
        authorization code. See Azure Active Directory's
        [authorization code documentation](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow)
        for more information about this authentication flow.
        - Multi-cloud support: client credentials accept the authority of an Azure Active
        Directory authentication endpoint as an `authority` keyword argument. Known
        authorities are defined in `azure.identity.KnownAuthorities`. The default
        authority is for Azure Public Cloud, `login.microsoftonline.com`
        (`KnownAuthorities.AZURE_PUBLIC_CLOUD`). An application running in Azure
        Government would use `KnownAuthorities.AZURE_GOVERNMENT` instead:
        >```
        >from azure.identity import DefaultAzureCredential, KnownAuthorities
        >credential = DefaultAzureCredential(authority=KnownAuthorities.AZURE_GOVERNMENT)
        >```
        
        ### Breaking changes:
        - Removed `client_secret` parameter from `InteractiveBrowserCredential`
        
        ### Fixes and improvements:
        - `UsernamePasswordCredential` correctly handles environment configuration with
        no tenant information ([#7260](https://github.com/Azure/azure-sdk-for-python/pull/7260))
        - user realm discovery requests are sent through credential pipelines
        ([#7260](https://github.com/Azure/azure-sdk-for-python/pull/7260))
        
        
        ## 1.0.0b3 (2019-09-10)
        ### New features:
        - `SharedTokenCacheCredential` authenticates with tokens stored in a local
        cache shared by Microsoft applications. This enables Azure SDK clients to
        authenticate silently after you've signed in to Visual Studio 2019, for
        example. `DefaultAzureCredential` includes `SharedTokenCacheCredential` when
        the shared cache is available, and environment variable `AZURE_USERNAME`
        is set. See the
        [README](https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/identity/azure-identity/README.md#single-sign-on)
        for more information.
        
        ### Dependency changes:
        - New dependency: [`msal-extensions`](https://pypi.org/project/msal-extensions/)
        0.1.1
        
        ## 1.0.0b2 (2019-08-05)
        ### Breaking changes:
        - Removed `azure.core.Configuration` from the public API in preparation for a
        revamped configuration API. Static `create_config` methods have been renamed
        `_create_config`, and will be removed in a future release.
        
        ### Dependency changes:
        - Adopted [azure-core](https://pypi.org/project/azure-core/) 1.0.0b2
          - If you later want to revert to a version requiring azure-core 1.0.0b1,
          of this or another Azure SDK library, you must explicitly install azure-core
          1.0.0b1 as well. For example:
          `pip install azure-core==1.0.0b1 azure-identity==1.0.0b1`
        - Adopted [MSAL](https://pypi.org/project/msal/) 0.4.1
        - New dependency for Python 2.7: [mock](https://pypi.org/project/mock/)
        
        ### New features:
        - Added credentials for authenticating users:
        [`DeviceCodeCredential`](https://azure.github.io/azure-sdk-for-python/ref/azure.identity.html#azure.identity.DeviceCodeCredential),
        [`InteractiveBrowserCredential`](https://azure.github.io/azure-sdk-for-python/ref/azure.identity.html#azure.identity.InteractiveBrowserCredential),
        [`UsernamePasswordCredential`](https://azure.github.io/azure-sdk-for-python/ref/azure.identity.html#azure.identity.UsernamePasswordCredential)
          - async versions of these credentials will be added in a future release
        
        ## 1.0.0b1 (2019-06-28)
        Version 1.0.0b1 is the first preview of our efforts to create a user-friendly
        and Pythonic authentication API for Azure SDK client libraries. For more
        information about preview releases of other Azure SDK libraries, please visit
        https://aka.ms/azure-sdk-preview1-python.
        
        This release supports service principal and managed identity authentication.
        See the
        [documentation](https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/identity/azure-identity/README.md)
        for more details. User authentication will be added in an upcoming preview
        release.
        
        This release supports only global Azure Active Directory tenants, i.e. those
        using the https://login.microsoftonline.com authentication endpoint.
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: License :: OSI Approved :: MIT License
Description-Content-Type: text/markdown
