py2docfx 0.1.16rc2051518__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/azure/core/tracing/opentelemetry.py

@@ -0,0 +1,256 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from __future__ import annotations
+from contextlib import contextmanager
+from contextvars import Token
+from typing import Optional, Dict, Sequence, cast, Callable, Iterator, TYPE_CHECKING
+
+from opentelemetry import context as otel_context_module, trace
+from opentelemetry.trace import (
+    Span,
+    SpanKind as OpenTelemetrySpanKind,
+    Link as OpenTelemetryLink,
+    StatusCode,
+)
+from opentelemetry.trace.propagation import get_current_span as get_current_span_otel
+from opentelemetry.propagate import extract, inject
+
+try:
+    from opentelemetry.context import _SUPPRESS_HTTP_INSTRUMENTATION_KEY  # type: ignore[attr-defined]
+except ImportError:
+    _SUPPRESS_HTTP_INSTRUMENTATION_KEY = "suppress_http_instrumentation"
+
+from .._version import VERSION
+from ._models import (
+    Attributes,
+    SpanKind as _SpanKind,
+)
+
+if TYPE_CHECKING:
+    from azure.core.tracing import Link, SpanKind
+
+
+_DEFAULT_SCHEMA_URL = "https://opentelemetry.io/schemas/1.23.1"
+_DEFAULT_MODULE_NAME = "azure-core"
+
+_KIND_MAPPINGS = {
+    _SpanKind.CLIENT: OpenTelemetrySpanKind.CLIENT,
+    _SpanKind.CONSUMER: OpenTelemetrySpanKind.CONSUMER,
+    _SpanKind.PRODUCER: OpenTelemetrySpanKind.PRODUCER,
+    _SpanKind.SERVER: OpenTelemetrySpanKind.SERVER,
+    _SpanKind.INTERNAL: OpenTelemetrySpanKind.INTERNAL,
+    _SpanKind.UNSPECIFIED: OpenTelemetrySpanKind.INTERNAL,
+}
+
+
+class OpenTelemetryTracer:
+    """A tracer that uses OpenTelemetry to trace operations.
+
+    :keyword library_name: The name of the library to use in the tracer.
+    :paramtype library_name: str
+    :keyword library_version: The version of the library to use in the tracer.
+    :paramtype library_version: str
+    :keyword schema_url: Specifies the Schema URL of the emitted spans. Defaults to
+        "https://opentelemetry.io/schemas/1.23.1".
+    :paramtype schema_url: str
+    :keyword attributes: Attributes to add to the emitted spans.
+    :paramtype attributes: Mapping[str, AttributeValue]
+    """
+
+    def __init__(
+        self,
+        *,
+        library_name: Optional[str] = None,
+        library_version: Optional[str] = None,
+        schema_url: Optional[str] = None,
+        attributes: Optional[Attributes] = None,
+    ) -> None:
+        self._tracer = trace.get_tracer(
+            instrumenting_module_name=library_name or _DEFAULT_MODULE_NAME,
+            instrumenting_library_version=library_version or VERSION,
+            schema_url=schema_url or _DEFAULT_SCHEMA_URL,
+            attributes=attributes,
+        )
+
+    def start_span(
+        self,
+        name: str,
+        *,
+        kind: SpanKind = _SpanKind.INTERNAL,
+        attributes: Optional[Attributes] = None,
+        links: Optional[Sequence[Link]] = None,
+    ) -> Span:
+        """Starts a span without setting it as the current span in the context.
+
+        :param name: The name of the span
+        :type name: str
+        :keyword kind: The kind of the span. INTERNAL by default.
+        :paramtype kind: ~azure.core.tracing.SpanKind
+        :keyword attributes: Attributes to add to the span.
+        :paramtype attributes: Mapping[str, AttributeValue]
+        :keyword links: Links to add to the span.
+        :paramtype links: list[~azure.core.tracing.Link]
+        :return: The span that was started
+        :rtype: ~opentelemetry.trace.Span
+        """
+        otel_kind = _KIND_MAPPINGS.get(kind, OpenTelemetrySpanKind.INTERNAL)
+        otel_links = self._parse_links(links)
+
+        otel_span = self._tracer.start_span(
+            name,
+            kind=otel_kind,
+            attributes=attributes,
+            links=otel_links,
+            record_exception=False,
+        )
+
+        return otel_span
+
+    @contextmanager
+    def start_as_current_span(
+        self,
+        name: str,
+        *,
+        kind: SpanKind = _SpanKind.INTERNAL,
+        attributes: Optional[Attributes] = None,
+        links: Optional[Sequence[Link]] = None,
+        end_on_exit: bool = True,
+    ) -> Iterator[Span]:
+        """Context manager that starts a span and sets it as the current span in the context.
+
+        .. code:: python
+
+            with tracer.start_as_current_span("span_name") as span:
+                # Do something with the span
+                span.set_attribute("key", "value")
+
+        :param name: The name of the span
+        :type name: str
+        :keyword kind: The kind of the span. INTERNAL by default.
+        :paramtype kind: ~azure.core.tracing.SpanKind
+        :keyword attributes: Attributes to add to the span.
+        :paramtype attributes: Optional[Attributes]
+        :keyword links: Links to add to the span.
+        :paramtype links: Optional[Sequence[Link]]
+        :keyword end_on_exit: Whether to end the span when exiting the context manager. Defaults to True.
+        :paramtype end_on_exit: bool
+        :return: The span that was started
+        :rtype: Iterator[~opentelemetry.trace.Span]
+        """
+        span = self.start_span(name, kind=kind, attributes=attributes, links=links)
+        with trace.use_span(  # pylint: disable=not-context-manager
+            span, record_exception=False, end_on_exit=end_on_exit
+        ) as span:
+            yield span
+
+    @classmethod
+    @contextmanager
+    def use_span(cls, span: Span, *, end_on_exit: bool = True) -> Iterator[Span]:
+        """Context manager that takes a non-active span and activates it in the current context.
+
+        :param span: The span to set as the current span
+        :type span: ~opentelemetry.trace.Span
+        :keyword end_on_exit: Whether to end the span when exiting the context manager. Defaults to True.
+        :paramtype end_on_exit: bool
+        :return: The span that was activated.
+        :rtype: Iterator[~opentelemetry.trace.Span]
+        """
+        with trace.use_span(  # pylint: disable=not-context-manager
+            span, record_exception=False, end_on_exit=end_on_exit
+        ) as active_span:
+            yield active_span
+
+    @staticmethod
+    def set_span_error_status(span: Span, description: Optional[str] = None) -> None:
+        """Set the status of a span to ERROR with the provided description, if any.
+
+        :param span: The span to set the ERROR status on.
+        :type span: ~opentelemetry.trace.Span
+        :param description: An optional description of the error.
+        :type description: str
+        """
+        span.set_status(StatusCode.ERROR, description=description)
+
+    def _parse_links(self, links: Optional[Sequence[Link]]) -> Optional[Sequence[OpenTelemetryLink]]:
+        if not links:
+            return None
+
+        try:
+            otel_links = []
+            for link in links:
+                ctx = extract(link.headers)
+                span_ctx = get_current_span_otel(ctx).get_span_context()
+                otel_links.append(OpenTelemetryLink(span_ctx, link.attributes))
+            return otel_links
+        except AttributeError:
+            # We will just send the links as is if it's not ~azure.core.tracing.Link without
+            # any validation assuming the user knows what they are doing.
+            return cast(Sequence[OpenTelemetryLink], links)
+
+    @classmethod
+    def get_current_span(cls) -> Span:
+        """Returns the current span in the context.
+
+        :return: The current span
+        :rtype: ~opentelemetry.trace.Span
+        """
+        return get_current_span_otel()
+
+    @classmethod
+    def with_current_context(cls, func: Callable) -> Callable:
+        """Passes the current spans to the new context the function will be run in.
+
+        :param func: The function that will be run in the new context
+        :type func: callable
+        :return: The wrapped function
+        :rtype: callable
+        """
+        current_context = otel_context_module.get_current()
+
+        def call_with_current_context(*args, **kwargs):
+            token = None
+            try:
+                token = otel_context_module.attach(current_context)
+                return func(*args, **kwargs)
+            finally:
+                if token is not None:
+                    otel_context_module.detach(token)
+
+        return call_with_current_context
+
+    @classmethod
+    def get_trace_context(cls) -> Dict[str, str]:
+        """Returns the Trace Context header values associated with the current span.
+
+        These are generally the W3C Trace Context headers (i.e. "traceparent" and "tracestate").
+
+        :return: A key value pair dictionary
+        :rtype: dict[str, str]
+        """
+        trace_context: Dict[str, str] = {}
+        inject(trace_context)
+        return trace_context
+
+    @classmethod
+    def _suppress_auto_http_instrumentation(cls) -> Token:
+        """Enabled automatic HTTP instrumentation suppression.
+
+        Since azure-core already instruments HTTP calls, we need to suppress any automatic HTTP
+        instrumentation provided by other libraries to prevent duplicate spans. This has no effect if no
+        automatic HTTP instrumentation libraries are being used.
+
+        :return: A token that can be used to detach the suppression key from the context
+        :rtype: ~contextvars.Token
+        """
+        return otel_context_module.attach(otel_context_module.set_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY, True))
+
+    @classmethod
+    def _detach_from_context(cls, token: Token) -> None:
+        """Detach a token from the context.
+
+        :param token: The token to detach
+        :type token: ~contextvars.Token
+        """
+        otel_context_module.detach(token)

py2docfx/venv/venv1/Lib/site-packages/azure/core/utils/_connection_string_parser.py

@@ -17,8 +17,7 @@ def parse_connection_string(conn_str: str, case_sensitive_keys: bool = False) ->
         default), all keys will be lower-cased. If set to `True`, the original casing of the keys will be preserved.
     :rtype: Mapping
     :returns: Dict of connection string key/value pairs.
-    :raises:
-        ValueError: if each key in conn_str does not have a corresponding value and
+    :raises ValueError: if each key in conn_str does not have a corresponding value and
             for other bad formatting of connection strings - including duplicate
             args, bad syntax, etc.
     """

py2docfx/venv/venv1/Lib/site-packages/azure/core/utils/_messaging_shared.py

@@ -22,7 +22,7 @@ def _get_json_content(obj):
     :type obj: any
     :return: The JSON content of the object.
     :rtype: dict
-    :raises ValueError if JSON content cannot be loaded from the object
+    :raises ValueError: if JSON content cannot be loaded from the object.
     """
     msg = "Failed to load JSON content from the object."
     try:

py2docfx/venv/venv1/Lib/site-packages/azure/core/utils/_pipeline_transport_rest_shared.py

@@ -4,7 +4,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from __future__ import absolute_import
 from collections.abc import Mapping
 
 from io import BytesIO
@@ -130,6 +129,7 @@ def _prepare_multipart_body_helper(http_request: "HTTPRequestType", content_inde
     correct context (sync/async)
 
     Does nothing if "set_multipart_mixed" was never called.
+
     :param http_request: The http request whose multipart body we are trying
      to prepare
     :type http_request: any

py2docfx/venv/venv1/Lib/site-packages/azure/core/utils/_pipeline_transport_rest_shared_async.py

@@ -4,7 +4,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import asyncio
 from typing import (
     TYPE_CHECKING,
     List,
@@ -57,6 +56,8 @@ class _PartGenerator(AsyncIterator[HttpResponseType], Generic[HttpResponseType])
 
             # Not happy to make this code asyncio specific, but that's multipart only for now
             # If we need trio and multipart, let's reinvesitgate that later
+            import asyncio  # pylint: disable=do-not-import-asyncio
+
             await asyncio.gather(*[parse_responses(res) for res in responses])
 
         return responses

py2docfx/venv/venv1/Lib/site-packages/azure/core/utils/_utils.py

@@ -170,11 +170,11 @@ def get_running_async_lock() -> AsyncContextManager:
 
     :return: An instance of the running async library's Lock class.
     :rtype: AsyncContextManager
-    :raises: RuntimeError if the current context is not running under an async library.
+    :raises RuntimeError: if the current context is not running under an async library.
     """
 
     try:
-        import asyncio
+        import asyncio  # pylint: disable=do-not-import-asyncio
 
         # Check if we are running in an asyncio event loop.
         asyncio.get_running_loop()

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_constants.py

@@ -64,4 +64,5 @@ class EnvironmentVariables:
     AZURE_REGIONAL_AUTHORITY_NAME = "AZURE_REGIONAL_AUTHORITY_NAME"
 
     AZURE_FEDERATED_TOKEN_FILE = "AZURE_FEDERATED_TOKEN_FILE"
+    AZURE_TOKEN_CREDENTIALS = "AZURE_TOKEN_CREDENTIALS"
     WORKLOAD_IDENTITY_VARS = (AZURE_AUTHORITY_HOST, AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE)

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/default.py

@@ -133,6 +133,7 @@ class DefaultAzureCredential(ChainedTokenCredential):
 
         process_timeout = kwargs.pop("process_timeout", 10)
 
+        token_credentials_env = os.environ.get(EnvironmentVariables.AZURE_TOKEN_CREDENTIALS, "").strip().lower()
         exclude_workload_identity_credential = kwargs.pop("exclude_workload_identity_credential", False)
         exclude_environment_credential = kwargs.pop("exclude_environment_credential", False)
         exclude_managed_identity_credential = kwargs.pop("exclude_managed_identity_credential", False)
@@ -143,6 +144,26 @@ class DefaultAzureCredential(ChainedTokenCredential):
         exclude_interactive_browser_credential = kwargs.pop("exclude_interactive_browser_credential", True)
         exclude_powershell_credential = kwargs.pop("exclude_powershell_credential", False)
 
+        if token_credentials_env == "dev":
+            # In dev mode, use only developer credentials
+            exclude_environment_credential = True
+            exclude_managed_identity_credential = True
+            exclude_workload_identity_credential = True
+        elif token_credentials_env == "prod":
+            # In prod mode, use only production credentials
+            exclude_shared_token_cache_credential = True
+            exclude_visual_studio_code_credential = True
+            exclude_cli_credential = True
+            exclude_developer_cli_credential = True
+            exclude_powershell_credential = True
+            exclude_interactive_browser_credential = True
+        elif token_credentials_env != "":
+            # If the environment variable is set to something other than dev or prod, raise an error
+            raise ValueError(
+                f"Invalid value for {EnvironmentVariables.AZURE_TOKEN_CREDENTIALS}: {token_credentials_env}. "
+                "Valid values are 'dev' or 'prod'."
+            )
+
         credentials: List[SupportsTokenInfo] = []
         within_dac.set(True)
         if not exclude_environment_credential:
@@ -155,7 +176,7 @@ class DefaultAzureCredential(ChainedTokenCredential):
                         client_id=cast(str, client_id),
                         tenant_id=workload_identity_tenant_id,
                         token_file_path=os.environ[EnvironmentVariables.AZURE_FEDERATED_TOKEN_FILE],
-                        **kwargs
+                        **kwargs,
                     )
                 )
         if not exclude_managed_identity_credential:
@@ -163,7 +184,7 @@ class DefaultAzureCredential(ChainedTokenCredential):
                 ManagedIdentityCredential(
                     client_id=managed_identity_client_id,
                     _exclude_workload_identity_credential=exclude_workload_identity_credential,
-                    **kwargs
+                    **kwargs,
                 )
             )
         if not exclude_shared_token_cache_credential and SharedTokenCacheCredential.supported():

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/environment.py

@@ -5,10 +5,12 @@
 import logging
 import os
 from typing import Optional, Union, Any, cast
+import warnings
 from azure.core.credentials import AccessToken, AccessTokenInfo, TokenRequestOptions, SupportsTokenInfo
 
 from .. import CredentialUnavailableError
 from .._constants import EnvironmentVariables
+from .._internal import within_dac
 from .._internal.decorators import log_get_token
 from .certificate import CertificateCredential
 from .client_secret import ClientSecretCredential
@@ -22,8 +24,8 @@ _LOGGER = logging.getLogger(__name__)
 class EnvironmentCredential:
     """A credential configured by environment variables.
 
-    This credential is capable of authenticating as a service principal using a client secret or a certificate, or as
-    a user with a username and password. Configuration is attempted in this order, using these environment variables:
+    This credential is capable of authenticating as a service principal using a client secret or a certificate.
+    Configuration is attempted in this order, using these environment variables:
 
     Service principal with secret:
       - **AZURE_TENANT_ID**: ID of the service principal's tenant. Also called its 'directory' ID.
@@ -45,20 +47,6 @@ class EnvironmentCredential:
         "login.microsoftonline.com", the authority for Azure Public Cloud, which is the default
         when no value is given.
 
-    User with username and password:
-      **Deprecated**: Username and password authentication doesn't support multifactor authentication (MFA).
-      For more details on Microsoft Entra MFA enforcement, see https://aka.ms/azsdk/identity/mfa.
-
-      - **AZURE_CLIENT_ID**: the application's client ID
-      - **AZURE_USERNAME**: a username (usually an email address)
-      - **AZURE_PASSWORD**: that user's password
-      - **AZURE_TENANT_ID**: (optional) ID of the service principal's tenant. Also called its 'directory' ID.
-        If not provided, defaults to the 'organizations' tenant, which supports only Microsoft Entra work or
-        school accounts.
-      - **AZURE_AUTHORITY_HOST**: authority of a Microsoft Entra endpoint, for example
-        "login.microsoftonline.com", the authority for Azure Public Cloud, which is the default
-        when no value is given.
-
     .. admonition:: Example:
 
         .. literalinclude:: ../samples/credential_creation_code_snippets.py
@@ -96,8 +84,16 @@ class EnvironmentCredential:
                 username=os.environ[EnvironmentVariables.AZURE_USERNAME],
                 password=os.environ[EnvironmentVariables.AZURE_PASSWORD],
                 tenant_id=os.environ.get(EnvironmentVariables.AZURE_TENANT_ID),  # optional for username/password auth
+                _silence_deprecation_warning=True,  # avoid duplicate warning
                 **kwargs
             )
+            warnings.warn(
+                "Environment is configured to use username and password authentication. "
+                "This authentication method is deprecated, as it doesn't support multifactor authentication (MFA). "
+                "For more details, see https://aka.ms/azsdk/identity/mfa.",
+                DeprecationWarning,
+                stacklevel=3 if within_dac.get() else 2,
+            )
 
         if self._credential:
             _LOGGER.info("Environment is configured for %s", self._credential.__class__.__name__)

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/service_fabric.py

@@ -6,16 +6,37 @@ import functools
 import os
 from typing import Dict, Optional, Any
 
+from azure.core.credentials import AccessToken, AccessTokenInfo, TokenRequestOptions
+from azure.core.exceptions import ClientAuthenticationError
 from azure.core.pipeline.transport import HttpRequest
 
 from .._constants import EnvironmentVariables
 from .._internal.msal_managed_identity_client import MsalManagedIdentityClient
 
 
+SERVICE_FABRIC_ERROR_MESSAGE = (
+    "Specifying a client_id or identity_config is not supported by the Service Fabric managed identity environment. "
+    "The managed identity configuration is determined by the Service Fabric cluster resource configuration. "
+    "See https://aka.ms/servicefabricmi for more information."
+)
+
+
 class ServiceFabricCredential(MsalManagedIdentityClient):
     def get_unavailable_message(self, desc: str = "") -> str:
         return f"Service Fabric managed identity configuration not found in environment. {desc}"
 
+    def get_token(
+        self, *scopes: str, claims: Optional[str] = None, tenant_id: Optional[str] = None, **kwargs: Any
+    ) -> AccessToken:
+        if self._settings.get("client_id") or self._settings.get("identity_config"):
+            raise ClientAuthenticationError(message=SERVICE_FABRIC_ERROR_MESSAGE)
+        return super().get_token(*scopes, claims=claims, tenant_id=tenant_id, **kwargs)
+
+    def get_token_info(self, *scopes: str, options: Optional[TokenRequestOptions] = None) -> AccessTokenInfo:
+        if self._settings.get("client_id") or self._settings.get("identity_config"):
+            raise ClientAuthenticationError(message=SERVICE_FABRIC_ERROR_MESSAGE)
+        return super().get_token_info(*scopes, options=options)
+
 
 def _get_client_args(**kwargs: Any) -> Optional[Dict]:
     url = os.environ.get(EnvironmentVariables.IDENTITY_ENDPOINT)
@@ -28,7 +49,7 @@ def _get_client_args(**kwargs: Any) -> Optional[Dict]:
     return dict(
         kwargs,
         base_headers={"Secret": secret},
-        connection_verify=False,
+        connection_verify=False,  # pylint: disable=do-not-hardcode-connection-verify
         request_factory=functools.partial(_get_request, url),
     )
 

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/user_password.py

@@ -63,12 +63,16 @@ class UsernamePasswordCredential(InteractiveCredential):
     """
 
     def __init__(self, client_id: str, username: str, password: str, **kwargs: Any) -> None:
-        warnings.warn(
-            f"{self.__class__.__name__} is deprecated, as is it doesn't support multifactor "
-            "authentication (MFA). For more details, see https://aka.ms/azsdk/identity/mfa.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
+        if not kwargs.pop("_silence_deprecation_warning", False):
+            # Only emit the deprecation warning if the credential was constructed directly and not via
+            # EnvironmentCredential since EnvironmentCredential will emit its own deprecation
+            # warning if it is used to create a UsernamePasswordCredential.
+            warnings.warn(
+                f"{self.__class__.__name__} is deprecated, as it doesn't support multifactor "
+                "authentication (MFA). For more details, see https://aka.ms/azsdk/identity/mfa.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
         # The base class will accept an AuthenticationRecord, allowing this credential to authenticate silently the
         # first time it's asked for a token. However, we want to ensure this first authentication is not silent, to
         # validate the given password. This class therefore doesn't document the authentication_record argument, and we

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/vscode.py

@@ -6,6 +6,7 @@ import abc
 import os
 import sys
 from typing import cast, Any, Dict, Optional
+import warnings
 
 from azure.core.credentials import AccessToken, TokenRequestOptions, AccessTokenInfo
 from azure.core.exceptions import ClientAuthenticationError
@@ -26,6 +27,14 @@ else:
 
 class _VSCodeCredentialBase(abc.ABC):
     def __init__(self, **kwargs: Any) -> None:
+        warnings.warn(
+            "This credential is deprecated because the Azure Account extension for Visual Studio Code, which this "
+            "credential relies on, has been deprecated. See the Azure Account extension deprecation notice here: "
+            "https://github.com/microsoft/vscode-azure-account/issues/964. Consider using other developer credentials "
+            "such as AzureCliCredential, AzureDeveloperCliCredential, or AzurePowerShellCredential.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         super(_VSCodeCredentialBase, self).__init__()
 
         user_settings = get_user_settings()
@@ -107,10 +116,10 @@ class _VSCodeCredentialBase(abc.ABC):
 class VisualStudioCodeCredential(_VSCodeCredentialBase, GetTokenMixin):
     """Authenticates as the Azure user signed in to Visual Studio Code via the 'Azure Account' extension.
 
-    It's a `known issue <https://github.com/Azure/azure-sdk-for-python/issues/23249>`_ that this credential doesn't
-    work with `Azure Account extension <https://marketplace.visualstudio.com/items?itemName=ms-vscode.azure-account>`_
-    versions newer than **0.9.11**. A long-term fix to this problem is in progress. In the meantime, consider
-    authenticating with :class:`AzureCliCredential`.
+    **Deprecated**: This credential is deprecated because the Azure Account extension for Visual Studio Code, which
+    this credential relies on, has been deprecated. See the Azure Account extension deprecation notice here:
+    https://github.com/microsoft/vscode-azure-account/issues/964. Consider using other developer credentials such as
+    AzureCliCredential, AzureDeveloperCliCredential, or AzurePowerShellCredential.
 
     :keyword str authority: Authority of a Microsoft Entra endpoint, for example "login.microsoftonline.com".
         This argument is required for a custom cloud and usually unnecessary otherwise. Defaults to the authority

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_internal/auth_code_redirect_handler.py

@@ -35,15 +35,13 @@ class AuthCodeRedirectHandler(BaseHTTPRequestHandler):
 class AuthCodeRedirectServer(HTTPServer):
     """HTTP server that listens for the redirect request following an authorization code authentication"""
 
-    query_params = {}  # type: Mapping[str, Any]
+    query_params: Mapping[str, Any] = {}
 
-    def __init__(self, hostname, port, timeout):
-        # type: (str, int, int) -> None
+    def __init__(self, hostname: str, port: int, timeout: int) -> None:
         HTTPServer.__init__(self, (hostname, port), AuthCodeRedirectHandler)
         self.timeout = timeout
 
-    def wait_for_redirect(self):
-        # type: () -> Mapping[str, Any]
+    def wait_for_redirect(self) -> Mapping[str, Any]:
         while not self.query_params:
             try:
                 self.handle_request()

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_internal/msal_client.py

@@ -131,7 +131,8 @@ class MsalClient:  # pylint:disable=client-accepts-api-version-keyword
             # response to an auth request, so no credential will want to include it with an exception
             content = response.context.get(ContentDecodePolicy.CONTEXT_NAME)
             if content and "error" in content:
-                self._local.error = (content["error"], response.http_response)
+                error_code = content["error"] if isinstance(content, dict) else "oauth_error"
+                self._local.error = (error_code, response.http_response)
 
     def __getstate__(self) -> Dict[str, Any]:  # pylint:disable=client-method-name-no-double-underscore
         state = self.__dict__.copy()

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_persistent_cache.py

@@ -67,8 +67,9 @@ def _load_persistent_cache(
     return msal_extensions.PersistedTokenCache(persistence)
 
 
-def _get_persistence(allow_unencrypted, account_name, cache_name):
-    # type: (bool, str, str) -> msal_extensions.persistence.BasePersistence
+def _get_persistence(
+    allow_unencrypted: bool, account_name: str, cache_name: str
+) -> "msal_extensions.persistence.BasePersistence":
     """Get an msal_extensions persistence instance for the current platform.
 
     On Windows the cache is a file protected by the Data Protection API. On Linux and macOS the cache is stored by

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_version.py

@@ -2,4 +2,4 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-VERSION = "1.21.0"
+VERSION = "1.23.0"

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/azd_cli.py

@@ -2,7 +2,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 import logging
 import os
 import shutil

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/azure_cli.py

@@ -2,7 +2,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 import logging
 import os
 import shutil

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/azure_powershell.py

@@ -2,7 +2,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 import sys
 from typing import Any, cast, List, Optional
 from azure.core.credentials import AccessToken, AccessTokenInfo, TokenRequestOptions

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/chained.py

@@ -2,7 +2,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 import logging
 from typing import Any, Optional, cast