py2docfx 0.1.16.dev2052678__py3-none-any.whl → 0.1.16.dev2064350__py3-none-any.whl

py2docfx/venv/basevenv/Lib/site-packages/wheel/_metadata.py

@@ -0,0 +1,184 @@
+"""
+Tools for converting old- to new-style metadata.
+"""
+
+from __future__ import annotations
+
+import functools
+import itertools
+import os.path
+import re
+import textwrap
+from collections.abc import Generator, Iterable, Iterator
+from email.message import Message
+from email.parser import Parser
+from typing import Literal
+
+from packaging.requirements import Requirement
+
+
+def _nonblank(str: str) -> bool | Literal[""]:
+    return str and not str.startswith("#")
+
+
+@functools.singledispatch
+def yield_lines(iterable: Iterable[str]) -> Iterator[str]:
+    r"""
+    Yield valid lines of a string or iterable.
+    >>> list(yield_lines(''))
+    []
+    >>> list(yield_lines(['foo', 'bar']))
+    ['foo', 'bar']
+    >>> list(yield_lines('foo\nbar'))
+    ['foo', 'bar']
+    >>> list(yield_lines('\nfoo\n#bar\nbaz #comment'))
+    ['foo', 'baz #comment']
+    >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n']))
+    ['foo', 'bar', 'baz', 'bing']
+    """
+    return itertools.chain.from_iterable(map(yield_lines, iterable))
+
+
+@yield_lines.register(str)
+def _(text: str) -> Iterator[str]:
+    return filter(_nonblank, map(str.strip, text.splitlines()))
+
+
+def split_sections(
+    s: str | Iterator[str],
+) -> Generator[tuple[str | None, list[str]], None, None]:
+    """Split a string or iterable thereof into (section, content) pairs
+    Each ``section`` is a stripped version of the section header ("[section]")
+    and each ``content`` is a list of stripped lines excluding blank lines and
+    comment-only lines.  If there are any such lines before the first section
+    header, they're returned in a first ``section`` of ``None``.
+    """
+    section = None
+    content: list[str] = []
+    for line in yield_lines(s):
+        if line.startswith("["):
+            if line.endswith("]"):
+                if section or content:
+                    yield section, content
+                section = line[1:-1].strip()
+                content = []
+            else:
+                raise ValueError("Invalid section heading", line)
+        else:
+            content.append(line)
+
+    # wrap up last segment
+    yield section, content
+
+
+def safe_extra(extra: str) -> str:
+    """Convert an arbitrary string to a standard 'extra' name
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+    """
+    return re.sub("[^A-Za-z0-9.-]+", "_", extra).lower()
+
+
+def safe_name(name: str) -> str:
+    """Convert an arbitrary string to a standard distribution name
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub("[^A-Za-z0-9.]+", "-", name)
+
+
+def requires_to_requires_dist(requirement: Requirement) -> str:
+    """Return the version specifier for a requirement in PEP 345/566 fashion."""
+    if requirement.url:
+        return " @ " + requirement.url
+
+    requires_dist: list[str] = []
+    for spec in requirement.specifier:
+        requires_dist.append(spec.operator + spec.version)
+
+    if requires_dist:
+        return " " + ",".join(sorted(requires_dist))
+    else:
+        return ""
+
+
+def convert_requirements(requirements: list[str]) -> Iterator[str]:
+    """Yield Requires-Dist: strings for parsed requirements strings."""
+    for req in requirements:
+        parsed_requirement = Requirement(req)
+        spec = requires_to_requires_dist(parsed_requirement)
+        extras = ",".join(sorted(safe_extra(e) for e in parsed_requirement.extras))
+        if extras:
+            extras = f"[{extras}]"
+
+        yield safe_name(parsed_requirement.name) + extras + spec
+
+
+def generate_requirements(
+    extras_require: dict[str | None, list[str]],
+) -> Iterator[tuple[str, str]]:
+    """
+    Convert requirements from a setup()-style dictionary to
+    ('Requires-Dist', 'requirement') and ('Provides-Extra', 'extra') tuples.
+
+    extras_require is a dictionary of {extra: [requirements]} as passed to setup(),
+    using the empty extra {'': [requirements]} to hold install_requires.
+    """
+    for extra, depends in extras_require.items():
+        condition = ""
+        extra = extra or ""
+        if ":" in extra:  # setuptools extra:condition syntax
+            extra, condition = extra.split(":", 1)
+
+        extra = safe_extra(extra)
+        if extra:
+            yield "Provides-Extra", extra
+            if condition:
+                condition = "(" + condition + ") and "
+            condition += f"extra == '{extra}'"
+
+        if condition:
+            condition = " ; " + condition
+
+        for new_req in convert_requirements(depends):
+            canonical_req = str(Requirement(new_req + condition))
+            yield "Requires-Dist", canonical_req
+
+
+def pkginfo_to_metadata(egg_info_path: str, pkginfo_path: str) -> Message:
+    """
+    Convert .egg-info directory with PKG-INFO to the Metadata 2.1 format
+    """
+    with open(pkginfo_path, encoding="utf-8") as headers:
+        pkg_info = Parser().parse(headers)
+
+    pkg_info.replace_header("Metadata-Version", "2.1")
+    # Those will be regenerated from `requires.txt`.
+    del pkg_info["Provides-Extra"]
+    del pkg_info["Requires-Dist"]
+    requires_path = os.path.join(egg_info_path, "requires.txt")
+    if os.path.exists(requires_path):
+        with open(requires_path, encoding="utf-8") as requires_file:
+            requires = requires_file.read()
+
+        parsed_requirements = sorted(split_sections(requires), key=lambda x: x[0] or "")
+        for extra, reqs in parsed_requirements:
+            for key, value in generate_requirements({extra: reqs}):
+                if (key, value) not in pkg_info.items():
+                    pkg_info[key] = value
+
+    description = pkg_info["Description"]
+    if description:
+        description_lines = pkg_info["Description"].splitlines()
+        dedented_description = "\n".join(
+            # if the first line of long_description is blank,
+            # the first line here will be indented.
+            (
+                description_lines[0].lstrip(),
+                textwrap.dedent("\n".join(description_lines[1:])),
+                "\n",
+            )
+        )
+        pkg_info.set_payload(dedented_description)
+        del pkg_info["Description"]
+
+    return pkg_info

py2docfx/venv/basevenv/Lib/site-packages/wheel/bdist_wheel.py

@@ -1,26 +1,15 @@
-from typing import TYPE_CHECKING
 from warnings import warn
 
-warn(
-    "The 'wheel' package is no longer the canonical location of the 'bdist_wheel' "
-    "command, and will be removed in a future release. Please update to setuptools "
-    "v70.1 or later which contains an integrated version of this command.",
-    DeprecationWarning,
-    stacklevel=1,
-)
+ERROR = """\
+The 'wheel.bdist_wheel' module has been removed.
+Please update your setuptools to v70.1 or later.
+If you're explicitly importing 'wheel.bdist_wheel', please update your import to point \
+to 'setuptools.command.bdist_wheel' instead.
+"""
 
-if TYPE_CHECKING:
-    from ._bdist_wheel import bdist_wheel as bdist_wheel
-else:
-    try:
-        # Better integration/compatibility with setuptools:
-        # in the case new fixes or PEPs are implemented in setuptools
-        # there is no need to backport them to the deprecated code base.
-        # This is useful in the case of old packages in the ecosystem
-        # that are still used but have low maintenance.
-        from setuptools.command.bdist_wheel import bdist_wheel
-    except ImportError:
-        # Only used in the case of old setuptools versions.
-        # If the user wants to get the latest fixes/PEPs,
-        # they are encouraged to address the deprecation warning.
-        from ._bdist_wheel import bdist_wheel as bdist_wheel
+try:
+    from setuptools.command.bdist_wheel import bdist_wheel as bdist_wheel
+except ModuleNotFoundError as exc:
+    raise ImportError(ERROR) from exc
+
+warn(ERROR, DeprecationWarning, stacklevel=2)

py2docfx/venv/basevenv/Lib/site-packages/wheel/macosx_libfile.py

@@ -1,4 +1,8 @@
 """
+IMPORTANT: DO NOT IMPORT THIS MODULE DIRECTLY.
+THIS IS ONLY KEPT IN PLACE FOR BACKWARDS COMPATIBILITY WITH
+setuptools.command.bdist_wheel.
+
 This module contains function to analyse dynamic library
 headers to extract system information
 

py2docfx/venv/basevenv/Lib/site-packages/wheel/metadata.py

@@ -1,183 +1,17 @@
-"""
-Tools for converting old- to new-style metadata.
-"""
-
-from __future__ import annotations
-
-import functools
-import itertools
-import os.path
-import re
-import textwrap
-from email.message import Message
-from email.parser import Parser
-from typing import Generator, Iterable, Iterator, Literal
-
-from .vendored.packaging.requirements import Requirement
-
-
-def _nonblank(str: str) -> bool | Literal[""]:
-    return str and not str.startswith("#")
-
-
-@functools.singledispatch
-def yield_lines(iterable: Iterable[str]) -> Iterator[str]:
-    r"""
-    Yield valid lines of a string or iterable.
-    >>> list(yield_lines(''))
-    []
-    >>> list(yield_lines(['foo', 'bar']))
-    ['foo', 'bar']
-    >>> list(yield_lines('foo\nbar'))
-    ['foo', 'bar']
-    >>> list(yield_lines('\nfoo\n#bar\nbaz #comment'))
-    ['foo', 'baz #comment']
-    >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n']))
-    ['foo', 'bar', 'baz', 'bing']
-    """
-    return itertools.chain.from_iterable(map(yield_lines, iterable))
-
-
-@yield_lines.register(str)
-def _(text: str) -> Iterator[str]:
-    return filter(_nonblank, map(str.strip, text.splitlines()))
-
-
-def split_sections(
-    s: str | Iterator[str],
-) -> Generator[tuple[str | None, list[str]], None, None]:
-    """Split a string or iterable thereof into (section, content) pairs
-    Each ``section`` is a stripped version of the section header ("[section]")
-    and each ``content`` is a list of stripped lines excluding blank lines and
-    comment-only lines.  If there are any such lines before the first section
-    header, they're returned in a first ``section`` of ``None``.
-    """
-    section = None
-    content: list[str] = []
-    for line in yield_lines(s):
-        if line.startswith("["):
-            if line.endswith("]"):
-                if section or content:
-                    yield section, content
-                section = line[1:-1].strip()
-                content = []
-            else:
-                raise ValueError("Invalid section heading", line)
-        else:
-            content.append(line)
-
-    # wrap up last segment
-    yield section, content
-
-
-def safe_extra(extra: str) -> str:
-    """Convert an arbitrary string to a standard 'extra' name
-    Any runs of non-alphanumeric characters are replaced with a single '_',
-    and the result is always lowercased.
-    """
-    return re.sub("[^A-Za-z0-9.-]+", "_", extra).lower()
-
-
-def safe_name(name: str) -> str:
-    """Convert an arbitrary string to a standard distribution name
-    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
-    """
-    return re.sub("[^A-Za-z0-9.]+", "-", name)
-
-
-def requires_to_requires_dist(requirement: Requirement) -> str:
-    """Return the version specifier for a requirement in PEP 345/566 fashion."""
-    if requirement.url:
-        return " @ " + requirement.url
-
-    requires_dist: list[str] = []
-    for spec in requirement.specifier:
-        requires_dist.append(spec.operator + spec.version)
-
-    if requires_dist:
-        return " " + ",".join(sorted(requires_dist))
-    else:
-        return ""
-
-
-def convert_requirements(requirements: list[str]) -> Iterator[str]:
-    """Yield Requires-Dist: strings for parsed requirements strings."""
-    for req in requirements:
-        parsed_requirement = Requirement(req)
-        spec = requires_to_requires_dist(parsed_requirement)
-        extras = ",".join(sorted(safe_extra(e) for e in parsed_requirement.extras))
-        if extras:
-            extras = f"[{extras}]"
-
-        yield safe_name(parsed_requirement.name) + extras + spec
-
-
-def generate_requirements(
-    extras_require: dict[str | None, list[str]],
-) -> Iterator[tuple[str, str]]:
-    """
-    Convert requirements from a setup()-style dictionary to
-    ('Requires-Dist', 'requirement') and ('Provides-Extra', 'extra') tuples.
-
-    extras_require is a dictionary of {extra: [requirements]} as passed to setup(),
-    using the empty extra {'': [requirements]} to hold install_requires.
-    """
-    for extra, depends in extras_require.items():
-        condition = ""
-        extra = extra or ""
-        if ":" in extra:  # setuptools extra:condition syntax
-            extra, condition = extra.split(":", 1)
-
-        extra = safe_extra(extra)
-        if extra:
-            yield "Provides-Extra", extra
-            if condition:
-                condition = "(" + condition + ") and "
-            condition += f"extra == '{extra}'"
-
-        if condition:
-            condition = " ; " + condition
-
-        for new_req in convert_requirements(depends):
-            canonical_req = str(Requirement(new_req + condition))
-            yield "Requires-Dist", canonical_req
-
-
-def pkginfo_to_metadata(egg_info_path: str, pkginfo_path: str) -> Message:
-    """
-    Convert .egg-info directory with PKG-INFO to the Metadata 2.1 format
-    """
-    with open(pkginfo_path, encoding="utf-8") as headers:
-        pkg_info = Parser().parse(headers)
-
-    pkg_info.replace_header("Metadata-Version", "2.1")
-    # Those will be regenerated from `requires.txt`.
-    del pkg_info["Provides-Extra"]
-    del pkg_info["Requires-Dist"]
-    requires_path = os.path.join(egg_info_path, "requires.txt")
-    if os.path.exists(requires_path):
-        with open(requires_path, encoding="utf-8") as requires_file:
-            requires = requires_file.read()
-
-        parsed_requirements = sorted(split_sections(requires), key=lambda x: x[0] or "")
-        for extra, reqs in parsed_requirements:
-            for key, value in generate_requirements({extra: reqs}):
-                if (key, value) not in pkg_info.items():
-                    pkg_info[key] = value
-
-    description = pkg_info["Description"]
-    if description:
-        description_lines = pkg_info["Description"].splitlines()
-        dedented_description = "\n".join(
-            # if the first line of long_description is blank,
-            # the first line here will be indented.
-            (
-                description_lines[0].lstrip(),
-                textwrap.dedent("\n".join(description_lines[1:])),
-                "\n",
-            )
-        )
-        pkg_info.set_payload(dedented_description)
-        del pkg_info["Description"]
-
-    return pkg_info
+from warnings import warn
+
+from ._metadata import convert_requirements as convert_requirements
+from ._metadata import generate_requirements as generate_requirements
+from ._metadata import pkginfo_to_metadata as pkginfo_to_metadata
+from ._metadata import requires_to_requires_dist as requires_to_requires_dist
+from ._metadata import safe_extra as safe_extra
+from ._metadata import safe_name as safe_name
+from ._metadata import split_sections as split_sections
+
+warn(
+    f"The {__name__!r} package has been made private and should no longer be imported. "
+    f"Please either copy the code or find an alternative library to import it from, as "
+    f"this warning will be removed in a future version of 'wheel'.",
+    DeprecationWarning,
+    stacklevel=2,
+)

py2docfx/venv/basevenv/Lib/site-packages/wheel/wheelfile.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
+__all__ = ["WHEEL_INFO_RE", "WheelFile", "WheelError"]
+
+import base64
 import csv
 import hashlib
+import logging
 import os.path
 import re
 import stat
@@ -10,17 +14,8 @@ from io import StringIO, TextIOWrapper
 from typing import IO, TYPE_CHECKING, Literal
 from zipfile import ZIP_DEFLATED, ZipFile, ZipInfo
 
-from wheel.cli import WheelError
-from wheel.util import log, urlsafe_b64decode, urlsafe_b64encode
-
 if TYPE_CHECKING:
-    from typing import Protocol, Sized, Union
-
-    from typing_extensions import Buffer
-
-    StrPath = Union[str, os.PathLike[str]]
-
-    class SizedBuffer(Sized, Buffer, Protocol): ...
+    from _typeshed import SizedBuffer, StrPath
 
 
 # Non-greedy matching of an optional build number may be too clever (more
@@ -32,8 +27,27 @@ WHEEL_INFO_RE = re.compile(
 )
 MINIMUM_TIMESTAMP = 315532800  # 1980-01-01 00:00:00 UTC
 
+log = logging.getLogger("wheel")
+
+
+class WheelError(Exception):
+    pass
 
-def get_zipinfo_datetime(timestamp: float | None = None):
+
+def urlsafe_b64encode(data: bytes) -> bytes:
+    """urlsafe_b64encode without padding"""
+    return base64.urlsafe_b64encode(data).rstrip(b"=")
+
+
+def urlsafe_b64decode(data: bytes) -> bytes:
+    """urlsafe_b64decode without padding"""
+    pad = b"=" * (4 - (len(data) & 3))
+    return base64.urlsafe_b64decode(data + pad)
+
+
+def get_zipinfo_datetime(
+    timestamp: float | None = None,
+) -> tuple[int, int, int, int, int]:
     # Some applications need reproducible .whl files, but they can't do this without
     # forcing the timestamp of the individual ZipInfo objects. See issue #143.
     timestamp = int(os.environ.get("SOURCE_DATE_EPOCH", timestamp or time.time()))
@@ -140,8 +154,8 @@ class WheelFile(ZipFile):
 
         return ef
 
-    def write_files(self, base_dir: str):
-        log.info(f"creating '{self.filename}' and adding '{base_dir}' to it")
+    def write_files(self, base_dir: str) -> None:
+        log.info("creating %r and adding %r to it", self.filename, base_dir)
         deferred: list[tuple[str, str]] = []
         for root, dirnames, filenames in os.walk(base_dir):
             # Sort the directory names so that `os.walk` will walk them in a
@@ -184,7 +198,7 @@ class WheelFile(ZipFile):
         zinfo_or_arcname: str | ZipInfo,
         data: SizedBuffer | str,
         compress_type: int | None = None,
-    ):
+    ) -> None:
         if isinstance(zinfo_or_arcname, str):
             zinfo_or_arcname = ZipInfo(
                 zinfo_or_arcname, date_time=get_zipinfo_datetime()
@@ -201,7 +215,7 @@ class WheelFile(ZipFile):
             if isinstance(zinfo_or_arcname, ZipInfo)
             else zinfo_or_arcname
         )
-        log.info(f"adding '{fname}'")
+        log.info("adding %r", fname)
         if fname != self.record_path:
             hash_ = self._default_algorithm(data)
             self._file_hashes[fname] = (
@@ -210,7 +224,7 @@ class WheelFile(ZipFile):
             )
             self._file_sizes[fname] = len(data)
 
-    def close(self):
+    def close(self) -> None:
         # Write RECORD
         if self.fp is not None and self.mode == "w" and self._file_hashes:
             data = StringIO()

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

@@ -9,4 +9,4 @@
 # regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "1.32.0"
+VERSION = "1.33.0"

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

@@ -147,7 +147,7 @@ class AzureKeyCredential:
     It provides the ability to update the key without creating a new client.
 
     :param str key: The key used to authenticate to an Azure service
-    :raises: TypeError
+    :raises TypeError: If the key is not a string.
     """
 
     def __init__(self, key: str) -> None:
@@ -185,7 +185,7 @@ class AzureSasCredential:
     It provides the ability to update the shared access signature without creating a new client.
 
     :param str signature: The shared access signature used to authenticate to an Azure service
-    :raises: TypeError
+    :raises TypeError: If the signature is not a string.
     """
 
     def __init__(self, signature: str) -> None:
@@ -209,7 +209,8 @@ class AzureSasCredential:
         to update long-lived clients.
 
         :param str signature: The shared access signature used to authenticate to an Azure service
-        :raises: ValueError or TypeError
+        :raises ValueError: If the signature is None or empty.
+        :raises TypeError: If the signature is not a string.
         """
         if not signature:
             raise ValueError("The signature used for updating can not be None or empty")
@@ -224,7 +225,7 @@ class AzureNamedKeyCredential:
 
     :param str name: The name of the credential used to authenticate to an Azure service.
     :param str key: The key used to authenticate to an Azure service.
-    :raises: TypeError
+    :raises TypeError: If the name or key is not a string.
     """
 
     def __init__(self, name: str, key: str) -> None:

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/_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__"):