Bump cherrypy from 18.9.0 to 18.10.0 (#2353)

* Bump cherrypy from 18.9.0 to 18.10.0

Bumps [cherrypy](https://github.com/cherrypy/cherrypy) from 18.9.0 to 18.10.0.
- [Changelog](https://github.com/cherrypy/cherrypy/blob/main/CHANGES.rst)
- [Commits](https://github.com/cherrypy/cherrypy/compare/v18.9.0...v18.10.0)

---
updated-dependencies:
- dependency-name: cherrypy
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update cherrypy==18.10.0

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: JonnyWong16 <9099342+JonnyWong16@users.noreply.github.com>

[skip ci]

lib/typeguard/_checkers.py

@@ -32,22 +32,24 @@ from typing import (
     Union,
 )
 from unittest.mock import Mock
+from weakref import WeakKeyDictionary
 
 try:
     import typing_extensions
 except ImportError:
     typing_extensions = None  # type: ignore[assignment]
 
+# Must use this because typing.is_typeddict does not recognize
+# TypedDict from typing_extensions, and as of version 4.12.0
+# typing_extensions.TypedDict is different from typing.TypedDict
+# on all versions.
+from typing_extensions import is_typeddict
+
 from ._config import ForwardRefPolicy
 from ._exceptions import TypeCheckError, TypeHintWarning
 from ._memo import TypeCheckMemo
 from ._utils import evaluate_forwardref, get_stacklevel, get_type_name, qualified_name
 
-if sys.version_info >= (3, 13):
-    from typing import is_typeddict
-else:
-    from typing_extensions import is_typeddict
-
 if sys.version_info >= (3, 11):
     from typing import (
         Annotated,
@@ -87,6 +89,9 @@ generic_alias_types: tuple[type, ...] = (type(List), type(List[Any]))
 if sys.version_info >= (3, 9):
     generic_alias_types += (types.GenericAlias,)
 
+protocol_check_cache: WeakKeyDictionary[
+    type[Any], dict[type[Any], TypeCheckError | None]
+] = WeakKeyDictionary()
 
 # Sentinel
 _missing = object()
@@ -649,19 +654,96 @@ def check_protocol(
     args: tuple[Any, ...],
     memo: TypeCheckMemo,
 ) -> None:
-    # TODO: implement proper compatibility checking and support non-runtime protocols
-    if getattr(origin_type, "_is_runtime_protocol", False):
-        if not isinstance(value, origin_type):
-            raise TypeCheckError(
-                f"is not compatible with the {origin_type.__qualname__} protocol"
+    subject: type[Any] = value if isclass(value) else type(value)
+
+    if subject in protocol_check_cache:
+        result_map = protocol_check_cache[subject]
+        if origin_type in result_map:
+            if exc := result_map[origin_type]:
+                raise exc
+            else:
+                return
+
+    # Collect a set of methods and non-method attributes present in the protocol
+    ignored_attrs = set(dir(typing.Protocol)) | {
+        "__annotations__",
+        "__non_callable_proto_members__",
+    }
+    expected_methods: dict[str, tuple[Any, Any]] = {}
+    expected_noncallable_members: dict[str, Any] = {}
+    for attrname in dir(origin_type):
+        # Skip attributes present in typing.Protocol
+        if attrname in ignored_attrs:
+            continue
+
+        member = getattr(origin_type, attrname)
+        if callable(member):
+            signature = inspect.signature(member)
+            argtypes = [
+                (p.annotation if p.annotation is not Parameter.empty else Any)
+                for p in signature.parameters.values()
+                if p.kind is not Parameter.KEYWORD_ONLY
+            ] or Ellipsis
+            return_annotation = (
+                signature.return_annotation
+                if signature.return_annotation is not Parameter.empty
+                else Any
             )
+            expected_methods[attrname] = argtypes, return_annotation
+        else:
+            expected_noncallable_members[attrname] = member
+
+    for attrname, annotation in typing.get_type_hints(origin_type).items():
+        expected_noncallable_members[attrname] = annotation
+
+    subject_annotations = typing.get_type_hints(subject)
+
+    # Check that all required methods are present and their signatures are compatible
+    result_map = protocol_check_cache.setdefault(subject, {})
+    try:
+        for attrname, callable_args in expected_methods.items():
+            try:
+                method = getattr(subject, attrname)
+            except AttributeError:
+                if attrname in subject_annotations:
+                    raise TypeCheckError(
+                        f"is not compatible with the {origin_type.__qualname__} protocol "
+                        f"because its {attrname!r} attribute is not a method"
+                    ) from None
+                else:
+                    raise TypeCheckError(
+                        f"is not compatible with the {origin_type.__qualname__} protocol "
+                        f"because it has no method named {attrname!r}"
+                    ) from None
+
+            if not callable(method):
+                raise TypeCheckError(
+                    f"is not compatible with the {origin_type.__qualname__} protocol "
+                    f"because its {attrname!r} attribute is not a callable"
+                )
+
+            # TODO: raise exception on added keyword-only arguments without defaults
+            try:
+                check_callable(method, Callable, callable_args, memo)
+            except TypeCheckError as exc:
+                raise TypeCheckError(
+                    f"is not compatible with the {origin_type.__qualname__} protocol "
+                    f"because its {attrname!r} method {exc}"
+                ) from None
+
+        # Check that all required non-callable members are present
+        for attrname in expected_noncallable_members:
+            # TODO: implement assignability checks for non-callable members
+            if attrname not in subject_annotations and not hasattr(subject, attrname):
+                raise TypeCheckError(
+                    f"is not compatible with the {origin_type.__qualname__} protocol "
+                    f"because it has no attribute named {attrname!r}"
+                )
+    except TypeCheckError as exc:
+        result_map[origin_type] = exc
+        raise
     else:
-        warnings.warn(
-            f"Typeguard cannot check the {origin_type.__qualname__} protocol because "
-            f"it is a non-runtime protocol. If you would like to type check this "
-            f"protocol, please use @typing.runtime_checkable",
-            stacklevel=get_stacklevel(),
-        )
+        result_map[origin_type] = None
 
 
 def check_byteslike(
@@ -852,7 +934,8 @@ def builtin_checker_lookup(
     elif is_typeddict(origin_type):
         return check_typed_dict
     elif isclass(origin_type) and issubclass(
-        origin_type, Tuple  # type: ignore[arg-type]
+        origin_type,
+        Tuple,  # type: ignore[arg-type]
     ):
         # NamedTuple
         return check_tuple

lib/typeguard/_pytest_plugin.py

@@ -2,21 +2,22 @@ from __future__ import annotations
 
 import sys
 import warnings
-from typing import Any, Literal
-
-from pytest import Config, Parser
+from typing import TYPE_CHECKING, Any, Literal
 
 from typeguard._config import CollectionCheckStrategy, ForwardRefPolicy, global_config
 from typeguard._exceptions import InstrumentationWarning
 from typeguard._importhook import install_import_hook
 from typeguard._utils import qualified_name, resolve_reference
 
+if TYPE_CHECKING:
+    from pytest import Config, Parser
+
 
 def pytest_addoption(parser: Parser) -> None:
     def add_ini_option(
         opt_type: (
             Literal["string", "paths", "pathlist", "args", "linelist", "bool"] | None
-        )
+        ),
     ) -> None:
         parser.addini(
             group.options[-1].names()[0][2:],

lib/typeguard/_suppression.py

@@ -28,7 +28,7 @@ def suppress_type_checks() -> ContextManager[None]: ...
 
 
 def suppress_type_checks(
-    func: Callable[P, T] | None = None
+    func: Callable[P, T] | None = None,
 ) -> Callable[P, T] | ContextManager[None]:
     """
     Temporarily suppress all type checking.

lib/typeguard/_utils.py

@@ -11,11 +11,21 @@ from weakref import WeakValueDictionary
 if TYPE_CHECKING:
     from ._memo import TypeCheckMemo
 
-if sys.version_info >= (3, 10):
+if sys.version_info >= (3, 13):
     from typing import get_args, get_origin
 
     def evaluate_forwardref(forwardref: ForwardRef, memo: TypeCheckMemo) -> Any:
-        return forwardref._evaluate(memo.globals, memo.locals, frozenset())
+        return forwardref._evaluate(
+            memo.globals, memo.locals, type_params=(), recursive_guard=frozenset()
+        )
+
+elif sys.version_info >= (3, 10):
+    from typing import get_args, get_origin
+
+    def evaluate_forwardref(forwardref: ForwardRef, memo: TypeCheckMemo) -> Any:
+        return forwardref._evaluate(
+            memo.globals, memo.locals, recursive_guard=frozenset()
+        )
 
 else:
     from typing_extensions import get_args, get_origin