py2docfx 0.1.9.dev1897607__py3-none-any.whl → 0.1.9.dev1917798__py3-none-any.whl

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

@@ -228,7 +228,9 @@ class HttpRequestBackcompatMixin:
         super(HttpRequestBackcompatMixin, self).__setattr__(attr, value)
 
     @property
-    def _multipart_mixed_info(self) -> Optional[Tuple[Sequence[Any], Sequence[Any], str, Dict[str, Any]]]:
+    def _multipart_mixed_info(
+        self,
+    ) -> Optional[Tuple[Sequence[Any], Sequence[Any], str, Dict[str, Any]]]:
         """DEPRECATED: Information used to make multipart mixed requests.
         This is deprecated and will be removed in a later release.
 

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

@@ -91,7 +91,7 @@ class _HttpResponseBackcompatMixinBase:
         :rtype: bytes
         """
         self.read()
-        return self.content  # pylint: disable=no-member
+        return self.content
 
     def _decode_parts(self, message, http_response_type, requests):
         """Helper for _decode_parts.

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

@@ -24,7 +24,9 @@
 #
 # --------------------------------------------------------------------------
 import collections.abc as collections
-from requests.structures import CaseInsensitiveDict  # pylint: disable=networking-import-outside-azure-core-transport
+from requests.structures import (  # pylint: disable=networking-import-outside-azure-core-transport
+    CaseInsensitiveDict,
+)
 
 from ._http_response_impl import (
     _HttpResponseBaseImpl,

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

@@ -115,7 +115,7 @@ def _datetime_as_isostr(dt: Union[datetime, date, time, timedelta]) -> str:
 class AzureJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
-    def default(self, o: Any) -> Any:  # pylint: disable=too-many-return-statements
+    def default(self, o: Any) -> Any:
         if isinstance(o, (bytes, bytearray)):
             return base64.b64encode(o).decode()
         try:

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

@@ -31,7 +31,19 @@ from enum import Enum
 import logging
 import os
 import sys
-from typing import Type, Optional, Callable, Union, Dict, Any, TypeVar, Tuple, Generic, Mapping, List
+from typing import (
+    Type,
+    Optional,
+    Callable,
+    Union,
+    Dict,
+    Any,
+    TypeVar,
+    Tuple,
+    Generic,
+    Mapping,
+    List,
+)
 from azure.core.tracing import AbstractSpan
 from ._azure_clouds import AzureClouds
 
@@ -144,7 +156,7 @@ def _get_opencensus_span() -> Optional[Type[AbstractSpan]]:
     :returns: OpenCensusSpan type or None
     """
     try:
-        from azure.core.tracing.ext.opencensus_span import (  # pylint:disable=redefined-outer-name
+        from azure.core.tracing.ext.opencensus_span import (
             OpenCensusSpan,
         )
 
@@ -160,7 +172,7 @@ def _get_opentelemetry_span() -> Optional[Type[AbstractSpan]]:
     :returns: OpenTelemetrySpan type or None
     """
     try:
-        from azure.core.tracing.ext.opentelemetry_span import (  # pylint:disable=redefined-outer-name
+        from azure.core.tracing.ext.opentelemetry_span import (
             OpenTelemetrySpan,
         )
 

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

@@ -7,7 +7,17 @@ from __future__ import annotations
 from enum import Enum
 from urllib.parse import urlparse
 
-from typing import Any, Sequence, Optional, Union, Callable, Dict, Type, Generic, TypeVar
+from typing import (
+    Any,
+    Sequence,
+    Optional,
+    Union,
+    Callable,
+    Dict,
+    Type,
+    Generic,
+    TypeVar,
+)
 from types import TracebackType
 from typing_extensions import Protocol, ContextManager, runtime_checkable
 from azure.core.pipeline.transport import HttpRequest, HttpResponse, AsyncHttpResponse
@@ -56,9 +66,7 @@ class AbstractSpan(Protocol, Generic[SpanType]):
     :type name: str
     """
 
-    def __init__(  # pylint: disable=super-init-not-called
-        self, span: Optional[SpanType] = None, name: Optional[str] = None, **kwargs: Any
-    ) -> None:
+    def __init__(self, span: Optional[SpanType] = None, name: Optional[str] = None, **kwargs: Any) -> None:
         pass
 
     def span(self, name: str = "child_span", **kwargs: Any) -> AbstractSpan[SpanType]:
@@ -263,7 +271,9 @@ class HttpSpanMixin:
     _ERROR_TYPE = "error.type"
 
     def set_http_attributes(
-        self: AbstractSpan, request: HttpRequestType, response: Optional[HttpResponseType] = None
+        self: AbstractSpan,
+        request: HttpRequestType,
+        response: Optional[HttpResponseType] = None,
     ) -> None:
         """
         Add correct attributes for a http client span.

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

@@ -54,7 +54,7 @@ def get_function_and_class_name(func: Callable, *args: object) -> str:
         return func.__qualname__
     except AttributeError:
         if args:
-            return "{}.{}".format(args[0].__class__.__name__, func.__name__)  # pylint: disable=protected-access
+            return "{}.{}".format(args[0].__class__.__name__, func.__name__)
         return func.__name__
 
 

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

@@ -68,6 +68,14 @@ def distributed_trace(
 
     Span will use the func name or "name_of_span".
 
+    Note:
+
+    This decorator SHOULD NOT be used by application developers. It's
+    intended to be called by Azure client libraries only.
+
+    Application developers should use OpenTelemetry or other tracing libraries to
+    instrument their applications.
+
     :param callable __func: A function to decorate
     :keyword name_of_span: The span name to replace func name if necessary
     :paramtype name_of_span: str
@@ -89,6 +97,9 @@ def distributed_trace(
             merge_span = kwargs.pop("merge_span", False)
             passed_in_parent = kwargs.pop("parent_span", None)
 
+            # Assume this will be popped in DistributedTracingPolicy.
+            func_tracing_attributes = kwargs.pop("tracing_attributes", tracing_attributes)
+
             span_impl_type = settings.tracing_implementation()
             if span_impl_type is None:
                 return func(*args, **kwargs)
@@ -100,7 +111,7 @@ def distributed_trace(
             with change_context(passed_in_parent):
                 name = name_of_span or get_function_and_class_name(func, *args)
                 with span_impl_type(name=name, kind=kind) as span:
-                    for key, value in tracing_attributes.items():
+                    for key, value in func_tracing_attributes.items():
                         span.add_attribute(key, value)
                     return func(*args, **kwargs)
 

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

@@ -27,7 +27,16 @@
 
 import functools
 
-from typing import Awaitable, Callable, Any, TypeVar, overload, Optional, Mapping, TYPE_CHECKING
+from typing import (
+    Awaitable,
+    Callable,
+    Any,
+    TypeVar,
+    overload,
+    Optional,
+    Mapping,
+    TYPE_CHECKING,
+)
 from typing_extensions import ParamSpec
 from .common import change_context, get_function_and_class_name
 from . import SpanKind as _SpanKind
@@ -56,8 +65,8 @@ def distributed_trace_async(
     pass
 
 
-def distributed_trace_async(
-    __func: Optional[Callable[P, Awaitable[T]]] = None,  # pylint: disable=unused-argument
+def distributed_trace_async(  # pylint: disable=unused-argument
+    __func: Optional[Callable[P, Awaitable[T]]] = None,
     *,
     name_of_span: Optional[str] = None,
     kind: Optional["SpanKind"] = None,
@@ -68,6 +77,14 @@ def distributed_trace_async(
 
     Span will use the func name or "name_of_span".
 
+    Note:
+
+    This decorator SHOULD NOT be used by application developers. It's
+    intended to be called by Azure client libraries only.
+
+    Application developers should use OpenTelemetry or other tracing libraries to
+    instrument their applications.
+
     :param callable __func: A function to decorate
     :keyword name_of_span: The span name to replace func name if necessary
     :paramtype name_of_span: str
@@ -89,6 +106,9 @@ def distributed_trace_async(
             merge_span = kwargs.pop("merge_span", False)
             passed_in_parent = kwargs.pop("parent_span", None)
 
+            # Assume this will be popped in DistributedTracingPolicy.
+            func_tracing_attributes = kwargs.get("tracing_attributes", tracing_attributes)
+
             span_impl_type = settings.tracing_implementation()
             if span_impl_type is None:
                 return await func(*args, **kwargs)
@@ -100,7 +120,7 @@ def distributed_trace_async(
             with change_context(passed_in_parent):
                 name = name_of_span or get_function_and_class_name(func, *args)
                 with span_impl_type(name=name, kind=kind) as span:
-                    for key, value in tracing_attributes.items():
+                    for key, value in func_tracing_attributes.items():
                         span.add_attribute(key, value)
                     return await func(*args, **kwargs)
 

py2docfx/venv/venv1/Lib/site-packages/azure/core/tracing/ext/opencensus_span/__init__.py

@@ -4,6 +4,7 @@
 # ------------------------------------
 """Implements azure.core.tracing.AbstractSpan to wrap opencensus spans."""
 import warnings
+from typing import Dict, Optional, Union, Callable, Sequence, Any, Generator
 
 from opencensus.trace import Span, execution_context
 from opencensus.trace.tracer import Tracer
@@ -12,32 +13,22 @@ from opencensus.trace.link import Link
 from opencensus.trace.propagation import trace_context_http_header_format
 from opencensus.trace import config_integration as _config_integration
 
-from azure.core.tracing import SpanKind, HttpSpanMixin  # pylint: disable=no-name-in-module
+from azure.core.tracing import SpanKind, HttpSpanMixin  # type: ignore[attr-defined]  # pylint: disable=no-name-in-module
 
 from ._version import VERSION
 
-try:
-    from typing import TYPE_CHECKING
-except ImportError:
-    TYPE_CHECKING = False
-
-if TYPE_CHECKING:
-    from typing import Dict, Optional, Union, Callable, Sequence, Any
-
-    from azure.core.pipeline.transport import HttpRequest, HttpResponse
-
-    AttributeValue = Union[
-        str,
-        bool,
-        int,
-        float,
-        Sequence[str],
-        Sequence[bool],
-        Sequence[int],
-        Sequence[float],
-    ]
-    Attributes = Optional[Dict[str, AttributeValue]]
 
+AttributeValue = Union[
+    str,
+    bool,
+    int,
+    float,
+    Sequence[str],
+    Sequence[bool],
+    Sequence[int],
+    Sequence[float],
+]
+Attributes = Dict[str, AttributeValue]
 
 __version__ = VERSION
 
@@ -47,14 +38,13 @@ _config_integration.trace_integrations(["threading"])
 class OpenCensusSpan(HttpSpanMixin, object):
     """Wraps a given OpenCensus Span so that it implements azure.core.tracing.AbstractSpan"""
 
-    def __init__(self, span=None, name="span", **kwargs):
-        # type: (Optional[Span], Optional[str], Any) -> None
+    def __init__(self, span: Optional[Span] = None, name: Optional[str] = "span", **kwargs: Any) -> None:
         """
         If a span is not passed in, creates a new tracer. If the instrumentation key for Azure Exporter is given, will
         configure the azure exporter else will just create a new tracer.
 
         :param span: The OpenCensus span to wrap
-        :type span: :class: opencensus.trace.Span
+        :type span: ~opencensus.trace.Span
         :param name: The name of the OpenCensus span to create if a new span is needed
         :type name: str
         :keyword SpanKind kind: The span kind of this span.
@@ -63,21 +53,31 @@ class OpenCensusSpan(HttpSpanMixin, object):
         """
         tracer = self.get_current_tracer()
         value = kwargs.pop("kind", None)
-        kind = (
+        kind: Optional[SpanKind] = (
             OpenCensusSpanKind.CLIENT
             if value == SpanKind.CLIENT
-            else OpenCensusSpanKind.CLIENT
-            if value == SpanKind.PRODUCER
-            else OpenCensusSpanKind.SERVER  # No producer in opencensus
-            if value == SpanKind.SERVER
-            else OpenCensusSpanKind.CLIENT
-            if value == SpanKind.CONSUMER
-            else OpenCensusSpanKind.UNSPECIFIED  # No consumer in opencensus
-            if value == SpanKind.INTERNAL
-            else OpenCensusSpanKind.UNSPECIFIED  # No internal in opencensus
-            if value == SpanKind.UNSPECIFIED
-            else None
-        )  # type: SpanKind
+            else (
+                OpenCensusSpanKind.CLIENT
+                if value == SpanKind.PRODUCER
+                else (
+                    OpenCensusSpanKind.SERVER  # No producer in opencensus
+                    if value == SpanKind.SERVER
+                    else (
+                        OpenCensusSpanKind.CLIENT
+                        if value == SpanKind.CONSUMER
+                        else (
+                            OpenCensusSpanKind.UNSPECIFIED  # No consumer in opencensus
+                            if value == SpanKind.INTERNAL
+                            else (
+                                OpenCensusSpanKind.UNSPECIFIED  # No internal in opencensus
+                                if value == SpanKind.UNSPECIFIED
+                                else None
+                            )
+                        )
+                    )
+                )
+            )
+        )
         if value and kind is None:
             raise ValueError("Kind {} is not supported in OpenCensus".format(value))
 
@@ -99,41 +99,26 @@ class OpenCensusSpan(HttpSpanMixin, object):
                 self._span_instance.links = links
 
     @property
-    def span_instance(self):
-        # type: () -> Span
-        """
-        :return: The OpenCensus span that is being wrapped.
+    def span_instance(self) -> Span:
+        """The OpenCensus span that is being wrapped.
+
+        :rtype: ~opencensus.trace.Span
         """
         return self._span_instance
 
-    def span(self, name="span", **kwargs):
-        # type: (Optional[str], Any) -> OpenCensusSpan
-        """
-        Create a child span for the current span and append it to the child spans list in the span instance.
+    def span(self, name: Optional[str] = "span", **kwargs: Any) -> "OpenCensusSpan":
+        """Create a child span for the current span and append it to the child spans list in the span instance.
+
         :param name: Name of the child span
         :type name: str
         :keyword SpanKind kind: The span kind of this span.
         :keyword links: The list of links to be added to the span.
         :paramtype links: list[~azure.core.tracing.Link]
         :return: The OpenCensusSpan that is wrapping the child span instance
+        :rtype: OpenCensusSpan
         """
         return self.__class__(name=name, **kwargs)
 
-    @property
-    def kind(self):
-        # type: () -> Optional[SpanKind]
-        """Get the span kind of this span."""
-        value = self.span_instance.span_kind
-        return (
-            SpanKind.CLIENT
-            if value == OpenCensusSpanKind.CLIENT
-            else SpanKind.SERVER
-            if value == OpenCensusSpanKind.SERVER
-            else SpanKind.UNSPECIFIED
-            if value == OpenCensusSpanKind.UNSPECIFIED
-            else None
-        )
-
     _KIND_MAPPING = {
         SpanKind.CLIENT: OpenCensusSpanKind.CLIENT,
         SpanKind.PRODUCER: OpenCensusSpanKind.CLIENT,  # No producer in opencensus
@@ -143,42 +128,60 @@ class OpenCensusSpan(HttpSpanMixin, object):
         SpanKind.UNSPECIFIED: OpenCensusSpanKind.UNSPECIFIED,
     }
 
+    @property
+    def kind(self) -> Optional[SpanKind]:
+        """Get the span kind of this span.
+
+        :rtype: ~azure.core.tracing.SpanKind or None
+        """
+        value = self.span_instance.span_kind
+        return (
+            SpanKind.CLIENT
+            if value == OpenCensusSpanKind.CLIENT
+            else (
+                SpanKind.SERVER
+                if value == OpenCensusSpanKind.SERVER
+                else SpanKind.UNSPECIFIED if value == OpenCensusSpanKind.UNSPECIFIED else None
+            )
+        )
+
     @kind.setter
-    def kind(self, value):
-        # type: (SpanKind) -> None
-        """Set the span kind of this span."""
+    def kind(self, value: SpanKind) -> None:
+        """Set the span kind of this span.
+
+        :param value: The span kind of this span.
+        :type value: ~azure.core.tracing.SpanKind
+        """
         kind = self._KIND_MAPPING.get(value)
         if kind is None:
             raise ValueError("Kind {} is not supported in OpenCensus".format(value))
         self.span_instance.span_kind = kind
 
     def __enter__(self):
-        """Start a span."""
+        # Start a span.
         self.span_instance.__enter__()
         return self
 
     def __exit__(self, exception_type, exception_value, traceback):
-        """Finish a span."""
+        # Finish a span.
         self.span_instance.__exit__(exception_type, exception_value, traceback)
 
-    def start(self):
-        # type: () -> None
+    def start(self) -> None:
         """Set the start time for a span."""
         self.__enter__()
 
-    def finish(self):
-        # type: () -> None
+    def finish(self) -> None:
         """Set the end time for a span."""
         self.__exit__(None, None, None)
 
-    def to_header(self):
-        # type: () -> Dict[str, str]
-        """
-        Returns a dictionary with the header labels and values.
+    def to_header(self) -> Dict[str, str]:
+        """Returns a dictionary with the header labels and values.
+
         :return: A key value pair dictionary
+        :rtype: dict
         """
         tracer_from_context = self.get_current_tracer()
-        temp_headers = {}  # type: Dict[str, str]
+        temp_headers: Dict[str, str] = {}
         if tracer_from_context is not None:
             ctx = tracer_from_context.span_context
             try:
@@ -187,10 +190,8 @@ class OpenCensusSpan(HttpSpanMixin, object):
                 pass
         return temp_headers
 
-    def add_attribute(self, key, value):
-        # type: (str, Union[str, int]) -> None
-        """
-        Add attribute (key value pair) to the current span.
+    def add_attribute(self, key: str, value: Union[str, int]) -> None:
+        """Add attribute (key value pair) to the current span.
 
         :param key: The key of the key value pair
         :type key: str
@@ -215,61 +216,67 @@ class OpenCensusSpan(HttpSpanMixin, object):
         return self.to_header()["traceparent"]
 
     @classmethod
-    def link(cls, traceparent, attributes=None):
-        # type: (str, Attributes) -> None
-        """
-        Links the context to the current tracer.
+    def link(cls, traceparent: str, attributes: Optional[Attributes] = None) -> None:
+        """Links the context to the current tracer.
 
         :param traceparent: A complete traceparent
         :type traceparent: str
+        :param attributes: Attributes to be added to the link
+        :type attributes: dict or None
         """
         cls.link_from_headers({"traceparent": traceparent}, attributes)
 
     @classmethod
-    def link_from_headers(cls, headers, attributes=None):
-        # type: (Dict[str, str], Attributes) -> None
-        """
-        Given a dictionary, extracts the context and links the context to the current tracer.
+    def link_from_headers(cls, headers: Dict[str, str], attributes: Optional[Attributes] = None) -> None:
+        """Given a dictionary, extracts the context and links the context to the current tracer.
 
         :param headers: A key value pair dictionary
         :type headers: dict
+        :param attributes: Attributes to be added to the link
+        :type attributes: dict or None
         """
         ctx = trace_context_http_header_format.TraceContextPropagator().from_headers(headers)
         current_span = cls.get_current_span()
         current_span.add_link(Link(trace_id=ctx.trace_id, span_id=ctx.span_id, attributes=attributes))
 
     @classmethod
-    def get_current_span(cls):
-        # type: () -> Span
-        """
-        Get the current span from the execution context. Return None otherwise.
+    def get_current_span(cls) -> Span:
+        """Get the current span from the execution context.
+
+        :return: The current span
+        :rtype: ~opencensus.trace.Span
         """
         return execution_context.get_current_span()
 
     @classmethod
-    def get_current_tracer(cls):
-        # type: () -> Tracer
-        """
-        Get the current tracer from the execution context. Return None otherwise.
+    def get_current_tracer(cls) -> Tracer:
+        """Get the current tracer from the execution context.
+
+        :return: The current tracer
+        :rtype: ~opencensus.trace.tracer.Tracer
         """
         return execution_context.get_opencensus_tracer()
 
     @classmethod
-    def set_current_span(cls, span):
-        # type: (Span) -> None
+    def set_current_span(cls, span: Span) -> None:
         """
         Set the given span as the current span in the execution context.
 
         :param span: The span to set the current span as
-        :type span: :class: opencensus.trace.Span
+        :type span: ~opencensus.trace.Span
         """
         warnings.warn("set_current_span is deprecated, use change_context instead", DeprecationWarning)
         return execution_context.set_current_span(span)
 
     @classmethod
-    def change_context(cls, span):
-        # type: (Span) -> ContextManager
-        """Change the context for the life of this context manager."""
+    def change_context(cls, span: Span) -> Generator:
+        """Change the context for the life of this context manager.
+
+        :param span: The span to set the current span as
+        :type span: ~opencensus.trace.Span
+        :return: A generator that will change the context for the life of the context manager
+        :rtype: Generator
+        """
         original_span = cls.get_current_span()
         try:
             execution_context.set_current_span(span)
@@ -278,26 +285,28 @@ class OpenCensusSpan(HttpSpanMixin, object):
             execution_context.set_current_span(original_span)
 
     @classmethod
-    def set_current_tracer(cls, tracer):
-        # type: (Tracer) -> None
-        """
-        Set the given tracer as the current tracer in the execution context.
+    def set_current_tracer(cls, tracer: Tracer) -> None:
+        """Set the given tracer as the current tracer in the execution context.
+
         :param tracer: The tracer to set the current tracer as
-        :type tracer: :class: opencensus.trace.Tracer
+        :type tracer: ~opencensus.trace.tracer.Tracer
         """
         return execution_context.set_opencensus_tracer(tracer)
 
     @classmethod
-    def with_current_context(cls, func):
-        # type: (Callable) -> Callable
+    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 target the pass in instead of the function
+        :rtype: callable
         """
         try:
             import opencensus.ext.threading  # pylint: disable=unused-import
-        except ImportError:
-            raise ValueError("In order to trace threads with Opencensus, please install opencensus-ext-threading")
+        except ImportError as ex:
+            raise ValueError(
+                "In order to trace threads with Opencensus, please install opencensus-ext-threading"
+            ) from ex
         # Noop, once opencensus-ext-threading is installed threads get context for free.
         return func

py2docfx/venv/venv1/Lib/site-packages/azure/core/tracing/ext/opencensus_span/_version.py

@@ -3,4 +3,4 @@
 # Licensed under the MIT License.
 # ------------------------------------
 
-VERSION = "1.0.0b9"
+VERSION = "1.0.0b10"

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

@@ -335,7 +335,9 @@ def _parts_helper(
     return responses
 
 
-def _format_data_helper(data: "FileType") -> Union[Tuple[Optional[str], str], Tuple[Optional[str], "FileContent", str]]:
+def _format_data_helper(
+    data: "FileType",
+) -> Union[Tuple[Optional[str], str], Tuple[Optional[str], "FileContent", str]]:
     """Helper for _format_data.
 
     Format field data according to whether it is a stream or

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

@@ -5,7 +5,16 @@
 # license information.
 # --------------------------------------------------------------------------
 import asyncio
-from typing import TYPE_CHECKING, List, Generic, TypeVar, Type, Optional, AsyncIterator, Iterator
+from typing import (
+    TYPE_CHECKING,
+    List,
+    Generic,
+    TypeVar,
+    Type,
+    Optional,
+    AsyncIterator,
+    Iterator,
+)
 from ..pipeline import PipelineContext, PipelineRequest, PipelineResponse
 from ..pipeline._tools_async import await_result as _await_result