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

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

@@ -0,0 +1,67 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from typing import Optional, Union, Mapping, TYPE_CHECKING
+from functools import lru_cache
+
+if TYPE_CHECKING:
+    from .tracing.opentelemetry import OpenTelemetryTracer
+
+
+def _get_tracer_impl():
+    # Check if OpenTelemetry is available/installed.
+    try:
+        from .tracing.opentelemetry import OpenTelemetryTracer
+
+        return OpenTelemetryTracer
+    except ImportError:
+        return None
+
+
+@lru_cache
+def _get_tracer_cached(
+    library_name: Optional[str],
+    library_version: Optional[str],
+    schema_url: Optional[str],
+    attributes_key: Optional[frozenset],
+) -> Optional["OpenTelemetryTracer"]:
+    tracer_impl = _get_tracer_impl()
+    if tracer_impl:
+        # Convert attributes_key back to dict if needed
+        attributes = dict(attributes_key) if attributes_key else None
+        return tracer_impl(
+            library_name=library_name,
+            library_version=library_version,
+            schema_url=schema_url,
+            attributes=attributes,
+        )
+    return None
+
+
+def get_tracer(
+    *,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    schema_url: Optional[str] = None,
+    attributes: Optional[Mapping[str, Union[str, bool, int, float]]] = None,
+) -> Optional["OpenTelemetryTracer"]:
+    """Get the OpenTelemetry tracer instance if available.
+
+    If OpenTelemetry is not available, this method will return None. This method caches
+    the tracer instance for each unique set of parameters.
+
+    :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, Union[str, bool, int, float]]
+    :return: The OpenTelemetry tracer instance if available.
+    :rtype: Optional[~azure.core.tracing.opentelemetry.OpenTelemetryTracer]
+    """
+    attributes_key = frozenset(attributes.items()) if attributes else None
+    return _get_tracer_cached(library_name, library_version, schema_url, attributes_key)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/_base.py

@@ -53,6 +53,7 @@ _LOGGER = logging.getLogger(__name__)
 
 def cleanup_kwargs_for_transport(kwargs: Dict[str, str]) -> None:
     """Remove kwargs that are not meant for the transport layer.
+
     :param kwargs: The keyword arguments.
     :type kwargs: dict
 
@@ -62,8 +63,9 @@ def cleanup_kwargs_for_transport(kwargs: Dict[str, str]) -> None:
       to the transport layer. This code is needed to handle the case that the
       SensitiveHeaderCleanupPolicy is not added into the pipeline and "insecure_domain_change" is not popped.
     "enable_cae" is added to the `get_token` method of the `TokenCredential` protocol.
+    "tracing_options" is used in the DistributedTracingPolicy and tracing decorators.
     """
-    kwargs_to_remove = ["insecure_domain_change", "enable_cae"]
+    kwargs_to_remove = ["insecure_domain_change", "enable_cae", "tracing_options"]
     if not kwargs:
         return
     for key in kwargs_to_remove:

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/_base_async.py

@@ -200,7 +200,7 @@ class AsyncPipeline(
 
         # 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
+        import asyncio  # pylint: disable=do-not-import-asyncio
 
         await asyncio.gather(*[prepare_requests(req) for req in requests])
 

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/_tools.py

@@ -44,7 +44,7 @@ def await_result(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
     :type args: list
     :rtype: any
     :return: The result of the function
-    :raises: TypeError
+    :raises TypeError: If the function returns an awaitable object.
     """
     result = func(*args, **kwargs)
     if hasattr(result, "__await__"):

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_authentication.py

@@ -116,7 +116,7 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
     :param str scopes: Lets you specify the type of access needed.
     :keyword bool enable_cae: Indicates whether to enable Continuous Access Evaluation (CAE) on all requested
         tokens. Defaults to False.
-    :raises: :class:`~azure.core.exceptions.ServiceRequestError`
+    :raises ~azure.core.exceptions.ServiceRequestError: If the request fails.
     """
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
@@ -194,7 +194,6 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
         :returns: a bool indicating whether the policy should send the request
         :rtype: bool
         """
-        # pylint:disable=unused-argument
         headers = response.http_response.headers
         error = get_challenge_parameter(headers, "Bearer", "error")
         if error == "insufficient_claims":
@@ -245,7 +244,8 @@ class AzureKeyCredentialPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
     :type credential: ~azure.core.credentials.AzureKeyCredential
     :param str name: The name of the key header used for the credential.
     :keyword str prefix: The name of the prefix for the header value if any.
-    :raises: ValueError or TypeError
+    :raises ValueError: if name is None or empty.
+    :raises TypeError: if name is not a string or if credential is not an instance of AzureKeyCredential.
     """
 
     def __init__(  # pylint: disable=unused-argument
@@ -276,7 +276,7 @@ class AzureSasCredentialPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
 
     :param credential: The credential used to authenticate requests.
     :type credential: ~azure.core.credentials.AzureSasCredential
-    :raises: ValueError or TypeError
+    :raises ValueError: if credential is None.
     """
 
     def __init__(

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_authentication_async.py

@@ -61,7 +61,7 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
 
         :param request: The pipeline request object to be modified.
         :type request: ~azure.core.pipeline.PipelineRequest
-        :raises: :class:`~azure.core.exceptions.ServiceRequestError`
+        :raises ~azure.core.exceptions.ServiceRequestError: If the request fails.
         """
         _BearerTokenCredentialPolicyBase._enforce_https(request)  # pylint:disable=protected-access
 
@@ -139,7 +139,6 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
         :returns: a bool indicating whether the policy should send the request
         :rtype: bool
         """
-        # pylint:disable=unused-argument
         headers = response.http_response.headers
         error = get_challenge_parameter(headers, "Bearer", "error")
         if error == "insufficient_claims":

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_distributed_tracing.py

@@ -27,7 +27,7 @@
 import logging
 import sys
 import urllib.parse
-from typing import TYPE_CHECKING, Optional, Tuple, TypeVar, Union, Any, Type
+from typing import TYPE_CHECKING, Optional, Tuple, TypeVar, Union, Any, Type, Mapping, Dict
 from types import TracebackType
 
 from azure.core.pipeline import PipelineRequest, PipelineResponse
@@ -39,11 +39,12 @@ from azure.core.pipeline.transport import (
 from azure.core.rest import HttpResponse, HttpRequest
 from azure.core.settings import settings
 from azure.core.tracing import SpanKind
+from azure.core.tracing.common import change_context
+from azure.core.instrumentation import get_tracer
+from azure.core.tracing._models import TracingOptions
 
 if TYPE_CHECKING:
-    from azure.core.tracing._abstract_span import (
-        AbstractSpan,
-    )
+    from opentelemetry.trace import Span
 
 HTTPResponseType = TypeVar("HTTPResponseType", HttpResponse, LegacyHttpResponse)
 HTTPRequestType = TypeVar("HTTPRequestType", HttpRequest, LegacyHttpRequest)
@@ -61,10 +62,7 @@ def _default_network_span_namer(http_request: HTTPRequestType) -> str:
     :returns: The string to use as network span name
     :rtype: str
     """
-    path = urllib.parse.urlparse(http_request.url).path
-    if not path:
-        path = "/"
-    return path
+    return http_request.method
 
 
 class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
@@ -74,37 +72,95 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
     :type network_span_namer: callable[[~azure.core.pipeline.transport.HttpRequest], str]
     :keyword tracing_attributes: Attributes to set on all created spans
     :type tracing_attributes: dict[str, str]
+    :keyword instrumentation_config: Configuration for the instrumentation providers
+    :type instrumentation_config: dict[str, Any]
     """
 
     TRACING_CONTEXT = "TRACING_CONTEXT"
+    _SUPPRESSION_TOKEN = "SUPPRESSION_TOKEN"
+
+    # Current stable HTTP semantic conventions
+    _HTTP_RESEND_COUNT = "http.request.resend_count"
+    _USER_AGENT_ORIGINAL = "user_agent.original"
+    _HTTP_REQUEST_METHOD = "http.request.method"
+    _URL_FULL = "url.full"
+    _HTTP_RESPONSE_STATUS_CODE = "http.response.status_code"
+    _SERVER_ADDRESS = "server.address"
+    _SERVER_PORT = "server.port"
+    _ERROR_TYPE = "error.type"
+
+    # Azure attributes
     _REQUEST_ID = "x-ms-client-request-id"
+    _REQUEST_ID_ATTR = "az.client_request_id"
     _RESPONSE_ID = "x-ms-request-id"
-    _HTTP_RESEND_COUNT = "http.request.resend_count"
+    _RESPONSE_ID_ATTR = "az.service_request_id"
 
-    def __init__(self, **kwargs: Any):
+    def __init__(self, *, instrumentation_config: Optional[Mapping[str, Any]] = None, **kwargs: Any):
         self._network_span_namer = kwargs.get("network_span_namer", _default_network_span_namer)
         self._tracing_attributes = kwargs.get("tracing_attributes", {})
+        self._instrumentation_config = instrumentation_config
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
         ctxt = request.context.options
         try:
-            span_impl_type = settings.tracing_implementation()
-            if span_impl_type is None:
+            tracing_options: TracingOptions = ctxt.pop("tracing_options", {})
+            tracing_enabled = settings.tracing_enabled()
+
+            # User can explicitly disable tracing for this request.
+            user_enabled = tracing_options.get("enabled")
+            if user_enabled is False:
+                return
+
+            # If tracing is disabled globally and user didn't explicitly enable it, don't trace.
+            if not tracing_enabled and user_enabled is None:
                 return
 
+            span_impl_type = settings.tracing_implementation()
             namer = ctxt.pop("network_span_namer", self._network_span_namer)
             tracing_attributes = ctxt.pop("tracing_attributes", self._tracing_attributes)
             span_name = namer(request.http_request)
 
-            span = span_impl_type(name=span_name, kind=SpanKind.CLIENT)
-            for attr, value in tracing_attributes.items():
-                span.add_attribute(attr, value)
-            span.start()
+            span_attributes = {**tracing_attributes, **tracing_options.get("attributes", {})}
 
-            headers = span.to_header()
-            request.http_request.headers.update(headers)
+            if span_impl_type:
+                # If the plugin is enabled, prioritize it over the core tracing.
+                span = span_impl_type(name=span_name, kind=SpanKind.CLIENT)
+                for attr, value in span_attributes.items():
+                    span.add_attribute(attr, value)  # type: ignore
+
+                with change_context(span.span_instance):
+                    headers = span.to_header()
+                    request.http_request.headers.update(headers)
+                request.context[self.TRACING_CONTEXT] = span
+            else:
+                # Otherwise, use the core tracing.
+                config = self._instrumentation_config or {}
+                tracer = get_tracer(
+                    library_name=config.get("library_name"),
+                    library_version=config.get("library_version"),
+                    attributes=config.get("attributes"),
+                )
+                if not tracer:
+                    _LOGGER.warning(
+                        "Tracing is enabled, but not able to get an OpenTelemetry tracer. "
+                        "Please ensure that `opentelemetry-api` is installed."
+                    )
+                    return
+
+                otel_span = tracer.start_span(
+                    name=span_name,
+                    kind=SpanKind.CLIENT,
+                    attributes=span_attributes,
+                )
+
+                with tracer.use_span(otel_span, end_on_exit=False):
+                    trace_context_headers = tracer.get_trace_context()
+                    request.http_request.headers.update(trace_context_headers)
+
+                request.context[self.TRACING_CONTEXT] = otel_span
+                token = tracer._suppress_auto_http_instrumentation()  # pylint: disable=protected-access
+                request.context[self._SUPPRESSION_TOKEN] = token
 
-            request.context[self.TRACING_CONTEXT] = span
         except Exception as err:  # pylint: disable=broad-except
             _LOGGER.warning("Unable to start network span: %s", err)
 
@@ -126,21 +182,52 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
         if self.TRACING_CONTEXT not in request.context:
             return
 
-        span: "AbstractSpan" = request.context[self.TRACING_CONTEXT]
+        span = request.context[self.TRACING_CONTEXT]
+        if not span:
+            return
+
         http_request: Union[HttpRequest, LegacyHttpRequest] = request.http_request
-        if span is not None:
-            span.set_http_attributes(http_request, response=response)
-            if request.context.get("retry_count"):
-                span.add_attribute(self._HTTP_RESEND_COUNT, request.context["retry_count"])
-            request_id = http_request.headers.get(self._REQUEST_ID)
-            if request_id is not None:
-                span.add_attribute(self._REQUEST_ID, request_id)
-            if response and self._RESPONSE_ID in response.headers:
-                span.add_attribute(self._RESPONSE_ID, response.headers[self._RESPONSE_ID])
+
+        attributes: Dict[str, Any] = {}
+        if request.context.get("retry_count"):
+            attributes[self._HTTP_RESEND_COUNT] = request.context["retry_count"]
+        if http_request.headers.get(self._REQUEST_ID):
+            attributes[self._REQUEST_ID_ATTR] = http_request.headers[self._REQUEST_ID]
+        if response and self._RESPONSE_ID in response.headers:
+            attributes[self._RESPONSE_ID_ATTR] = response.headers[self._RESPONSE_ID]
+
+        # We'll determine if the span is from a plugin or the core tracing library based on the presence of the
+        # `set_http_attributes` method.
+        if hasattr(span, "set_http_attributes"):
+            # Plugin-based tracing
+            span.set_http_attributes(request=http_request, response=response)
+            for key, value in attributes.items():
+                span.add_attribute(key, value)
             if exc_info:
                 span.__exit__(*exc_info)
             else:
                 span.finish()
+        else:
+            # Native tracing
+            self._set_http_client_span_attributes(span, request=http_request, response=response)
+            span.set_attributes(attributes)
+            if exc_info:
+                # If there was an exception, set the error.type attribute.
+                exception_type = exc_info[0]
+                if exception_type:
+                    module = exception_type.__module__ if exception_type.__module__ != "builtins" else ""
+                    error_type = f"{module}.{exception_type.__qualname__}" if module else exception_type.__qualname__
+                    span.set_attribute(self._ERROR_TYPE, error_type)
+
+                span.__exit__(*exc_info)
+            else:
+                span.end()
+
+        suppression_token = request.context.get(self._SUPPRESSION_TOKEN)
+        if suppression_token:
+            tracer = get_tracer()
+            if tracer:
+                tracer._detach_from_context(suppression_token)  # pylint: disable=protected-access
 
     def on_response(
         self,
@@ -151,3 +238,39 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
 
     def on_exception(self, request: PipelineRequest[HTTPRequestType]) -> None:
         self.end_span(request, exc_info=sys.exc_info())
+
+    def _set_http_client_span_attributes(
+        self,
+        span: "Span",
+        request: Union[HttpRequest, LegacyHttpRequest],
+        response: Optional[HTTPResponseType] = None,
+    ) -> None:
+        """Add attributes to an HTTP client span.
+
+        :param span: The span to add attributes to.
+        :type span: ~opentelemetry.trace.Span
+        :param request: The request made
+        :type request: ~azure.core.rest.HttpRequest
+        :param response: The response received from the server. Is None if no response received.
+        :type response: ~azure.core.rest.HTTPResponse or ~azure.core.pipeline.transport.HttpResponse
+        """
+        attributes: Dict[str, Any] = {
+            self._HTTP_REQUEST_METHOD: request.method,
+            self._URL_FULL: request.url,
+        }
+
+        parsed_url = urllib.parse.urlparse(request.url)
+        if parsed_url.hostname:
+            attributes[self._SERVER_ADDRESS] = parsed_url.hostname
+        if parsed_url.port:
+            attributes[self._SERVER_PORT] = parsed_url.port
+
+        user_agent = request.headers.get("User-Agent")
+        if user_agent:
+            attributes[self._USER_AGENT_ORIGINAL] = user_agent
+        if response and response.status_code:
+            attributes[self._HTTP_RESPONSE_STATUS_CODE] = response.status_code
+            if response.status_code >= 400:
+                attributes[self._ERROR_TYPE] = str(response.status_code)
+
+        span.set_attributes(attributes)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_redirect.py

@@ -58,6 +58,7 @@ _LOGGER = logging.getLogger(__name__)
 
 def domain_changed(original_domain: Optional[str], url: str) -> bool:
     """Checks if the domain has changed.
+
     :param str original_domain: The original domain.
     :param str url: The new url.
     :rtype: bool
@@ -193,9 +194,9 @@ class RedirectPolicy(RedirectPolicyBase, HTTPPolicy[HTTPRequestType, HTTPRespons
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum redirects exceeded.
+        :return: The PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raises: ~azure.core.exceptions.TooManyRedirectsError if maximum redirects exceeded.
+        :raises ~azure.core.exceptions.TooManyRedirectsError: if maximum redirects exceeded.
         """
         retryable: bool = True
         redirect_settings = self.configure_redirects(request.context.options)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_redirect_async.py

@@ -65,9 +65,9 @@ class AsyncRedirectPolicy(RedirectPolicyBase, AsyncHTTPPolicy[HTTPRequestType, A
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum redirects exceeded.
+        :return: the PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raises: ~azure.core.exceptions.TooManyRedirectsError if maximum redirects exceeded.
+        :raises ~azure.core.exceptions.TooManyRedirectsError: if maximum redirects exceeded.
         """
         redirects_remaining = True
         redirect_settings = self.configure_redirects(request.context.options)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_retry.py

@@ -422,28 +422,21 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HTTPRequestType, HTTPResponseType]
 
     :keyword int retry_total: Total number of retries to allow. Takes precedence over other counts.
      Default value is 10.
-
     :keyword int retry_connect: How many connection-related errors to retry on.
      These are errors raised before the request is sent to the remote server,
      which we assume has not triggered the server to process the request. Default value is 3.
-
     :keyword int retry_read: How many times to retry on read errors.
      These errors are raised after the request was sent to the server, so the
      request may have side-effects. Default value is 3.
-
     :keyword int retry_status: How many times to retry on bad status codes. Default value is 3.
-
     :keyword float retry_backoff_factor: A backoff factor to apply between attempts after the second try
      (most errors are resolved immediately by a second try without a delay).
      In fixed mode, retry policy will always sleep for {backoff factor}.
      In 'exponential' mode, retry policy will sleep for: `{backoff factor} * (2 ** ({number of total retries} - 1))`
      seconds. If the backoff_factor is 0.1, then the retry will sleep
      for [0.0s, 0.2s, 0.4s, ...] between retries. The default value is 0.8.
-
     :keyword int retry_backoff_max: The maximum back off time. Default value is 120 seconds (2 minutes).
-
     :keyword RetryMode retry_mode: Fixed or exponential delay between attemps, default is exponential.
-
     :keyword int timeout: Timeout setting for the operation in seconds, default is 604800s (7 days).
 
     .. admonition:: Example:
@@ -522,10 +515,10 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HTTPRequestType, HTTPResponseType]
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum retries exceeded.
+        :return: The PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raises: ~azure.core.exceptions.AzureError if maximum retries exceeded.
-        :raises: ~azure.core.exceptions.ClientAuthenticationError if authentication
+        :raises ~azure.core.exceptions.AzureError: if maximum retries exceeded.
+        :raises ~azure.core.exceptions.ClientAuthenticationError: if authentication fails.
         """
         retry_active = True
         response = None

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_retry_async.py

@@ -57,23 +57,18 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HTTPRequestType, AsyncHT
 
     :keyword int retry_total: Total number of retries to allow. Takes precedence over other counts.
      Default value is 10.
-
     :keyword int retry_connect: How many connection-related errors to retry on.
      These are errors raised before the request is sent to the remote server,
      which we assume has not triggered the server to process the request. Default value is 3.
-
     :keyword int retry_read: How many times to retry on read errors.
      These errors are raised after the request was sent to the server, so the
      request may have side-effects. Default value is 3.
-
     :keyword int retry_status: How many times to retry on bad status codes. Default value is 3.
-
     :keyword float retry_backoff_factor: A backoff factor to apply between attempts after the second try
      (most errors are resolved immediately by a second try without a delay).
      Retry policy will sleep for: `{backoff factor} * (2 ** ({number of total retries} - 1))`
      seconds. If the backoff_factor is 0.1, then the retry will sleep
      for [0.0s, 0.2s, 0.4s, ...] between retries. The default value is 0.8.
-
     :keyword int retry_backoff_max: The maximum back off time. Default value is 120 seconds (2 minutes).
 
     .. admonition:: Example:
@@ -154,10 +149,10 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HTTPRequestType, AsyncHT
 
         :param request: The PipelineRequest object
         :type request: ~azure.core.pipeline.PipelineRequest
-        :return: Returns the PipelineResponse or raises error if maximum retries exceeded.
+        :return: The PipelineResponse.
         :rtype: ~azure.core.pipeline.PipelineResponse
-        :raise: ~azure.core.exceptions.AzureError if maximum retries exceeded.
-        :raise: ~azure.core.exceptions.ClientAuthenticationError if authentication fails
+        :raise ~azure.core.exceptions.AzureError: if maximum retries exceeded.
+        :raise ~azure.core.exceptions.ClientAuthenticationError: if authentication fails
         """
         retry_active = True
         response = None

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_universal.py

@@ -234,6 +234,7 @@ class UserAgentPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
 
     def add_user_agent(self, value: str) -> None:
         """Add value to current user agent with a space.
+
         :param str value: value to add to user agent.
         """
         self._user_agent = "{} {}".format(self._user_agent, value)
@@ -441,6 +442,7 @@ class HttpLoggingPolicy(
         self, request: PipelineRequest[HTTPRequestType]
     ) -> None:
         """Logs HTTP method, url and headers.
+
         :param request: The PipelineRequest object.
         :type request: ~azure.core.pipeline.PipelineRequest
         """

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_aiohttp.py

@@ -40,7 +40,7 @@ from types import TracebackType
 from collections.abc import AsyncIterator
 
 import logging
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 import codecs
 import aiohttp
 import aiohttp.client_exceptions
@@ -85,7 +85,6 @@ class AioHttpTransport(AsyncHttpTransport):
     :keyword session: The client session.
     :paramtype session: ~aiohttp.ClientSession
     :keyword bool session_owner: Session owner. Defaults True.
-
     :keyword bool use_env_settings: Uses proxy settings from environment. Defaults to True.
 
     .. admonition:: Example:

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_base_async.py

@@ -24,7 +24,6 @@
 #
 # --------------------------------------------------------------------------
 from __future__ import annotations
-import asyncio
 import abc
 from collections.abc import AsyncIterator
 from typing import (
@@ -168,4 +167,6 @@ class AsyncHttpTransport(
 
         :param float duration: The number of seconds to sleep.
         """
+        import asyncio  # pylint: disable=do-not-import-asyncio
+
         await asyncio.sleep(duration)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_requests_asyncio.py

@@ -23,7 +23,7 @@
 # IN THE SOFTWARE.
 #
 # --------------------------------------------------------------------------
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 from collections.abc import AsyncIterator
 import functools
 import logging

py2docfx/venv/venv1/Lib/site-packages/azure/core/polling/base_polling.py

@@ -113,15 +113,15 @@ def _succeeded(status):
 
 
 class BadStatus(Exception):
-    pass
+    """Exception raised when status is invalid."""
 
 
 class BadResponse(Exception):
-    pass
+    """Exception raised when response is invalid."""
 
 
 class OperationFailed(Exception):
-    pass
+    """Exception raised when operation failed or canceled."""
 
 
 def _as_json(response: AllHttpResponseType) -> Dict[str, Any]:

py2docfx/venv/venv1/Lib/site-packages/azure/core/rest/_aiohttp.py

@@ -24,7 +24,7 @@
 #
 # --------------------------------------------------------------------------
 import collections.abc
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 from itertools import groupby
 from typing import Iterator, cast
 from multidict import CIMultiDict
@@ -132,7 +132,7 @@ class _CIMultiDict(CIMultiDict):
     def __getitem__(self, key: str) -> str:
         return ", ".join(self.getall(key, []))
 
-    def get(self, key, default=None):
+    def get(self, key, /, default=None):
         values = self.getall(key, None)
         if values:
             values = ", ".join(values)

py2docfx/venv/venv1/Lib/site-packages/azure/core/rest/_http_response_impl_async.py

@@ -46,6 +46,7 @@ class AsyncHttpResponseBackcompatMixin(_HttpResponseBackcompatMixinBase):
     def parts(self):
         """DEPRECATED: Assuming the content-type is multipart/mixed, will return the parts as an async iterator.
         This is deprecated and will be removed in a later release.
+
         :rtype: AsyncIterator
         :return: The parts of the response
         :raises ValueError: If the content is not multipart/mixed
@@ -95,6 +96,7 @@ class AsyncHttpResponseImpl(_HttpResponseBaseImpl, _AsyncHttpResponse, AsyncHttp
 
     async def iter_raw(self, **kwargs: Any) -> AsyncIterator[bytes]:
         """Asynchronously iterates over the response's bytes. Will not decompress in the process
+
         :return: An async iterator of bytes from the response
         :rtype: AsyncIterator[bytes]
         """
@@ -105,6 +107,7 @@ class AsyncHttpResponseImpl(_HttpResponseBaseImpl, _AsyncHttpResponse, AsyncHttp
 
     async def iter_bytes(self, **kwargs: Any) -> AsyncIterator[bytes]:
         """Asynchronously iterates over the response's bytes. Will decompress in the process
+
         :return: An async iterator of bytes from the response
         :rtype: AsyncIterator[bytes]
         """

py2docfx/venv/venv1/Lib/site-packages/azure/core/rest/_requests_asyncio.py

@@ -23,7 +23,7 @@
 # IN THE SOFTWARE.
 #
 # --------------------------------------------------------------------------
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 from ._http_response_impl_async import AsyncHttpResponseImpl
 from ._requests_basic import _RestRequestsTransportResponseBase
 from ..pipeline.transport._requests_asyncio import AsyncioStreamDownloadGenerator