Enable Ruff PLC (Pylint Convention)

pyproject.toml

@@ -45,6 +45,7 @@ select = [
     "I", # isort
     "N", # pep8-naming
     "PGH", # pygrep-hooks
+    "PLC", # Pylint Convention
     "RUF", # Ruff-specific and unused-noqa
     "TRY", # tryceratops
     "UP", # pyupgrade
@@ -159,19 +160,26 @@ ignore = [
     # A lot of stubs are incomplete on purpose, and that's configured through pyright
     # Some ANN204 (special method) are autofixable in stubs, but not all.
     "ANN2", # Missing return type annotation for ...
-    # Most pep8-naming rules don't apply for third-party stubs like typeshed.
-    # N811 to N814 could apply, but we often use them to disambiguate a name whilst making it look like a more common one
-    "N8",
+    # Ruff 0.8.0 added sorting of __all__ and __slots_.
+    # There is no consensus on whether we want to apply this to stubs, so keeping the status quo.
+    # See https://github.com/python/typeshed/pull/13108
+    "RUF022", # `__all__` is not sorted
+    "RUF023", # `{}.__slots__` is not sorted
+    ###
     # Rules that are out of the control of stub authors:
+    ###
     "F403", # `from . import *` used; unable to detect undefined names
     # Stubs can sometimes re-export entire modules.
     # Issues with using a star-imported name will be caught by type-checkers.
     "F405", # may be undefined, or defined from star imports
-    # Ruff 0.8.0 added sorting of __all__ and __slots_.
-    # There is no consensus on whether we want to apply this to stubs, so keeping the status quo.
-    # See https://github.com/python/typeshed/pull/13108
-    "RUF022",
-    "RUF023",
+    # Most pep8-naming rules don't apply for third-party stubs like typeshed.
+    # N811 to N814 could apply, but we often use them to disambiguate a name whilst making it look like a more common one
+    "N8", # pep8-naming
+    "PLC2701", # Private name import from external module
+]
+"lib/ts_utils/**" = [
+    # Doesn't affect stubs. The only re-exports we have should be in our local lib ts_utils
+    "PLC0414", # Import alias does not rename original package
 ]
 "*_pb2.pyi" = [
     # Leave the docstrings as-is, matching source

stdlib/builtins.pyi

@@ -89,8 +89,8 @@ _T2 = TypeVar("_T2")
 _T3 = TypeVar("_T3")
 _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
-_SupportsNextT = TypeVar("_SupportsNextT", bound=SupportsNext[Any], covariant=True)
-_SupportsAnextT = TypeVar("_SupportsAnextT", bound=SupportsAnext[Any], covariant=True)
+_SupportsNextT_co = TypeVar("_SupportsNextT_co", bound=SupportsNext[Any], covariant=True)
+_SupportsAnextT_co = TypeVar("_SupportsAnextT_co", bound=SupportsAnext[Any], covariant=True)
 _AwaitableT = TypeVar("_AwaitableT", bound=Awaitable[Any])
 _AwaitableT_co = TypeVar("_AwaitableT_co", bound=Awaitable[Any], covariant=True)
 _P = ParamSpec("_P")
@@ -1319,7 +1319,7 @@ class _PathLike(Protocol[AnyStr_co]):
     def __fspath__(self) -> AnyStr_co: ...
 
 if sys.version_info >= (3, 10):
-    def aiter(async_iterable: SupportsAiter[_SupportsAnextT], /) -> _SupportsAnextT: ...
+    def aiter(async_iterable: SupportsAiter[_SupportsAnextT_co], /) -> _SupportsAnextT_co: ...
 
     class _SupportsSynchronousAnext(Protocol[_AwaitableT_co]):
         def __anext__(self) -> _AwaitableT_co: ...
@@ -1481,7 +1481,7 @@ class _GetItemIterable(Protocol[_T_co]):
     def __getitem__(self, i: int, /) -> _T_co: ...
 
 @overload
-def iter(object: SupportsIter[_SupportsNextT], /) -> _SupportsNextT: ...
+def iter(object: SupportsIter[_SupportsNextT_co], /) -> _SupportsNextT_co: ...
 @overload
 def iter(object: _GetItemIterable[_T], /) -> Iterator[_T]: ...
 @overload
@@ -1688,17 +1688,17 @@ def print(
     *values: object, sep: str | None = " ", end: str | None = "\n", file: _SupportsWriteAndFlush[str] | None = None, flush: bool
 ) -> None: ...
 
-_E = TypeVar("_E", contravariant=True)
-_M = TypeVar("_M", contravariant=True)
+_E_contra = TypeVar("_E_contra", contravariant=True)
+_M_contra = TypeVar("_M_contra", contravariant=True)
 
-class _SupportsPow2(Protocol[_E, _T_co]):
-    def __pow__(self, other: _E, /) -> _T_co: ...
+class _SupportsPow2(Protocol[_E_contra, _T_co]):
+    def __pow__(self, other: _E_contra, /) -> _T_co: ...
 
-class _SupportsPow3NoneOnly(Protocol[_E, _T_co]):
-    def __pow__(self, other: _E, modulo: None = None, /) -> _T_co: ...
+class _SupportsPow3NoneOnly(Protocol[_E_contra, _T_co]):
+    def __pow__(self, other: _E_contra, modulo: None = None, /) -> _T_co: ...
 
-class _SupportsPow3(Protocol[_E, _M, _T_co]):
-    def __pow__(self, other: _E, modulo: _M, /) -> _T_co: ...
+class _SupportsPow3(Protocol[_E_contra, _M_contra, _T_co]):
+    def __pow__(self, other: _E_contra, modulo: _M_contra, /) -> _T_co: ...
 
 _SupportsSomeKindOfPow = (  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
     _SupportsPow2[Any, Any] | _SupportsPow3NoneOnly[Any, Any] | _SupportsPow3[Any, Any, Any]
@@ -1734,11 +1734,11 @@ def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = None) ->
 @overload
 def pow(base: complex, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> complex: ...
 @overload
-def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
+def pow(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
 @overload
-def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
+def pow(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
 @overload
-def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...
+def pow(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co: ...
 @overload
 def pow(base: _SupportsSomeKindOfPow, exp: float, mod: None = None) -> Any: ...
 @overload

stdlib/contextlib.pyi

@@ -33,7 +33,7 @@ _T_co = TypeVar("_T_co", covariant=True)
 _T_io = TypeVar("_T_io", bound=IO[str] | None)
 _ExitT_co = TypeVar("_ExitT_co", covariant=True, bound=bool | None, default=bool | None)
 _F = TypeVar("_F", bound=Callable[..., Any])
-_G = TypeVar("_G", bound=Generator[Any, Any, Any] | AsyncGenerator[Any, Any], covariant=True)
+_G_co = TypeVar("_G_co", bound=Generator[Any, Any, Any] | AsyncGenerator[Any, Any], covariant=True)
 _P = ParamSpec("_P")
 
 _SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=None)
@@ -68,11 +68,11 @@ class ContextDecorator:
     def _recreate_cm(self) -> Self: ...
     def __call__(self, func: _F) -> _F: ...
 
-class _GeneratorContextManagerBase(Generic[_G]):
+class _GeneratorContextManagerBase(Generic[_G_co]):
     # Ideally this would use ParamSpec, but that requires (*args, **kwargs), which this isn't. see #6676
-    def __init__(self, func: Callable[..., _G], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-    gen: _G
-    func: Callable[..., _G]
+    def __init__(self, func: Callable[..., _G_co], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
+    gen: _G_co
+    func: Callable[..., _G_co]
     args: tuple[Any, ...]
     kwds: dict[str, Any]
 

stdlib/inspect.pyi

@@ -143,8 +143,8 @@ if sys.version_info >= (3, 11):
 _P = ParamSpec("_P")
 _T = TypeVar("_T")
 _F = TypeVar("_F", bound=Callable[..., Any])
-_T_cont = TypeVar("_T_cont", contravariant=True)
-_V_cont = TypeVar("_V_cont", contravariant=True)
+_T_contra = TypeVar("_T_contra", contravariant=True)
+_V_contra = TypeVar("_V_contra", contravariant=True)
 
 #
 # Types and members
@@ -228,11 +228,11 @@ def isasyncgenfunction(obj: Callable[_P, Any]) -> TypeGuard[Callable[_P, AsyncGe
 @overload
 def isasyncgenfunction(obj: object) -> TypeGuard[Callable[..., AsyncGeneratorType[Any, Any]]]: ...
 
-class _SupportsSet(Protocol[_T_cont, _V_cont]):
-    def __set__(self, instance: _T_cont, value: _V_cont, /) -> None: ...
+class _SupportsSet(Protocol[_T_contra, _V_contra]):
+    def __set__(self, instance: _T_contra, value: _V_contra, /) -> None: ...
 
-class _SupportsDelete(Protocol[_T_cont]):
-    def __delete__(self, instance: _T_cont, /) -> None: ...
+class _SupportsDelete(Protocol[_T_contra]):
+    def __delete__(self, instance: _T_contra, /) -> None: ...
 
 def isasyncgen(object: object) -> TypeIs[AsyncGeneratorType[Any, Any]]: ...
 def istraceback(object: object) -> TypeIs[TracebackType]: ...

stdlib/multiprocessing/connection.pyi

@@ -12,10 +12,10 @@ __all__ = ["Client", "Listener", "Pipe", "wait"]
 _Address: TypeAlias = str | tuple[str, int]
 
 # Defaulting to Any to avoid forcing generics on a lot of pre-existing code
-_SendT = TypeVar("_SendT", contravariant=True, default=Any)
-_RecvT = TypeVar("_RecvT", covariant=True, default=Any)
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=Any)
+_RecvT_co = TypeVar("_RecvT_co", covariant=True, default=Any)
 
-class _ConnectionBase(Generic[_SendT, _RecvT]):
+class _ConnectionBase(Generic[_SendT_contra, _RecvT_co]):
     def __init__(self, handle: SupportsIndex, readable: bool = True, writable: bool = True) -> None: ...
     @property
     def closed(self) -> bool: ...  # undocumented
@@ -26,21 +26,21 @@ class _ConnectionBase(Generic[_SendT, _RecvT]):
     def fileno(self) -> int: ...
     def close(self) -> None: ...
     def send_bytes(self, buf: ReadableBuffer, offset: int = 0, size: int | None = None) -> None: ...
-    def send(self, obj: _SendT) -> None: ...
+    def send(self, obj: _SendT_contra) -> None: ...
     def recv_bytes(self, maxlength: int | None = None) -> bytes: ...
     def recv_bytes_into(self, buf: Any, offset: int = 0) -> int: ...
-    def recv(self) -> _RecvT: ...
+    def recv(self) -> _RecvT_co: ...
     def poll(self, timeout: float | None = 0.0) -> bool: ...
     def __enter__(self) -> Self: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
     def __del__(self) -> None: ...
 
-class Connection(_ConnectionBase[_SendT, _RecvT]): ...
+class Connection(_ConnectionBase[_SendT_contra, _RecvT_co]): ...
 
 if sys.platform == "win32":
-    class PipeConnection(_ConnectionBase[_SendT, _RecvT]): ...
+    class PipeConnection(_ConnectionBase[_SendT_contra, _RecvT_co]): ...
 
 class Listener:
     def __init__(
@@ -66,8 +66,8 @@ else:
 
 def answer_challenge(connection: Connection[Any, Any], authkey: bytes) -> None: ...
 def wait(
-    object_list: Iterable[Connection[_SendT, _RecvT] | socket.socket | int], timeout: float | None = None
-) -> list[Connection[_SendT, _RecvT] | socket.socket | int]: ...
+    object_list: Iterable[Connection[_SendT_contra, _RecvT_co] | socket.socket | int], timeout: float | None = None
+) -> list[Connection[_SendT_contra, _RecvT_co] | socket.socket | int]: ...
 def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection[Any, Any]: ...
 
 # N.B. Keep this in sync with multiprocessing.context.BaseContext.Pipe.

stdlib/typing.pyi

@@ -510,15 +510,15 @@ class Awaitable(Protocol[_T_co]):
     def __await__(self) -> Generator[Any, Any, _T_co]: ...
 
 # Non-default variations to accommodate couroutines, and `AwaitableGenerator` having a 4th type parameter.
-_SendT_contra_nd = TypeVar("_SendT_contra_nd", contravariant=True)
-_ReturnT_co_nd = TypeVar("_ReturnT_co_nd", covariant=True)
+_SendT_nd_contra = TypeVar("_SendT_nd_contra", contravariant=True)
+_ReturnT_nd_co = TypeVar("_ReturnT_nd_co", covariant=True)
 
-class Coroutine(Awaitable[_ReturnT_co_nd], Generic[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd]):
+class Coroutine(Awaitable[_ReturnT_nd_co], Generic[_YieldT_co, _SendT_nd_contra, _ReturnT_nd_co]):
     __name__: str
     __qualname__: str
 
     @abstractmethod
-    def send(self, value: _SendT_contra_nd, /) -> _YieldT_co: ...
+    def send(self, value: _SendT_nd_contra, /) -> _YieldT_co: ...
     @overload
     @abstractmethod
     def throw(
@@ -534,9 +534,9 @@ class Coroutine(Awaitable[_ReturnT_co_nd], Generic[_YieldT_co, _SendT_contra_nd,
 # The parameters correspond to Generator, but the 4th is the original type.
 @type_check_only
 class AwaitableGenerator(
-    Awaitable[_ReturnT_co_nd],
-    Generator[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd],
-    Generic[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd, _S],
+    Awaitable[_ReturnT_nd_co],
+    Generator[_YieldT_co, _SendT_nd_contra, _ReturnT_nd_co],
+    Generic[_YieldT_co, _SendT_nd_contra, _ReturnT_nd_co, _S],
     metaclass=ABCMeta,
 ): ...
 

stubs/WTForms/wtforms/validators.pyi

@@ -42,7 +42,7 @@ __all__ = (
     "Disabled",
 )
 
-_ValuesT = TypeVar("_ValuesT", bound=Collection[Any], contravariant=True)
+_ValuesT_contra = TypeVar("_ValuesT_contra", bound=Collection[Any], contravariant=True)
 
 class ValidationError(ValueError):
     def __init__(self, message: str = "", *args: object) -> None: ...
@@ -150,9 +150,13 @@ class AnyOf:
     @overload
     def __init__(self, values: Collection[Any], message: str | None = None, values_formatter: None = None) -> None: ...
     @overload
-    def __init__(self, values: _ValuesT, message: str | None, values_formatter: Callable[[_ValuesT], str]) -> None: ...
+    def __init__(
+        self, values: _ValuesT_contra, message: str | None, values_formatter: Callable[[_ValuesT_contra], str]
+    ) -> None: ...
     @overload
-    def __init__(self, values: _ValuesT, message: str | None = None, *, values_formatter: Callable[[_ValuesT], str]) -> None: ...
+    def __init__(
+        self, values: _ValuesT_contra, message: str | None = None, *, values_formatter: Callable[[_ValuesT_contra], str]
+    ) -> None: ...
     def __call__(self, form: BaseForm, field: Field) -> None: ...
     @staticmethod
     def default_values_formatter(values: Iterable[object]) -> str: ...
@@ -164,9 +168,13 @@ class NoneOf:
     @overload
     def __init__(self, values: Collection[Any], message: str | None = None, values_formatter: None = None) -> None: ...
     @overload
-    def __init__(self, values: _ValuesT, message: str | None, values_formatter: Callable[[_ValuesT], str]) -> None: ...
+    def __init__(
+        self, values: _ValuesT_contra, message: str | None, values_formatter: Callable[[_ValuesT_contra], str]
+    ) -> None: ...
     @overload
-    def __init__(self, values: _ValuesT, message: str | None = None, *, values_formatter: Callable[[_ValuesT], str]) -> None: ...
+    def __init__(
+        self, values: _ValuesT_contra, message: str | None = None, *, values_formatter: Callable[[_ValuesT_contra], str]
+    ) -> None: ...
     def __call__(self, form: BaseForm, field: Field) -> None: ...
     @staticmethod
     def default_values_formatter(v: Iterable[object]) -> str: ...

stubs/boltons/boltons/tbutils.pyi

@@ -22,31 +22,31 @@ class Callpoint:
     def from_tb(cls, tb: TracebackType) -> Self: ...
     def tb_frame_str(self) -> str: ...
 
-_CallpointT = TypeVar("_CallpointT", bound=Callpoint, covariant=True, default=Callpoint)
+_CallpointT_co = TypeVar("_CallpointT_co", bound=Callpoint, covariant=True, default=Callpoint)
 
-class TracebackInfo(Generic[_CallpointT]):
-    callpoint_type: type[_CallpointT]
-    frames: list[_CallpointT]
-    def __init__(self, frames: list[_CallpointT]) -> None: ...
+class TracebackInfo(Generic[_CallpointT_co]):
+    callpoint_type: type[_CallpointT_co]
+    frames: list[_CallpointT_co]
+    def __init__(self, frames: list[_CallpointT_co]) -> None: ...
     @classmethod
     def from_frame(cls, frame: FrameType | None = None, level: int = 1, limit: int | None = None) -> Self: ...
     @classmethod
     def from_traceback(cls, tb: TracebackType | None = None, limit: int | None = None) -> Self: ...
     @classmethod
-    def from_dict(cls, d: Mapping[Literal["frames"], list[_CallpointT]]) -> Self: ...
-    def to_dict(self) -> dict[str, list[dict[str, _CallpointT]]]: ...
+    def from_dict(cls, d: Mapping[Literal["frames"], list[_CallpointT_co]]) -> Self: ...
+    def to_dict(self) -> dict[str, list[dict[str, _CallpointT_co]]]: ...
     def __len__(self) -> int: ...
-    def __iter__(self) -> Iterator[_CallpointT]: ...
+    def __iter__(self) -> Iterator[_CallpointT_co]: ...
     def get_formatted(self) -> str: ...
 
-_TracebackInfoT = TypeVar("_TracebackInfoT", bound=TracebackInfo, covariant=True, default=TracebackInfo)
+_TracebackInfoT_co = TypeVar("_TracebackInfoT_co", bound=TracebackInfo, covariant=True, default=TracebackInfo)
 
-class ExceptionInfo(Generic[_TracebackInfoT]):
-    tb_info_type: type[_TracebackInfoT]
+class ExceptionInfo(Generic[_TracebackInfoT_co]):
+    tb_info_type: type[_TracebackInfoT_co]
     exc_type: str
     exc_msg: str
-    tb_info: _TracebackInfoT
-    def __init__(self, exc_type: str, exc_msg: str, tb_info: _TracebackInfoT) -> None: ...
+    tb_info: _TracebackInfoT_co
+    def __init__(self, exc_type: str, exc_msg: str, tb_info: _TracebackInfoT_co) -> None: ...
     @classmethod
     def from_exc_info(cls, exc_type: type[BaseException], exc_value: BaseException, traceback: TracebackType) -> Self: ...
     @classmethod

stubs/networkx/networkx/algorithms/operators/binary.pyi

@@ -15,10 +15,10 @@ def difference(G: Graph[_Node], H: Graph[_Node]): ...
 @_dispatchable
 def symmetric_difference(G: Graph[_Node], H: Graph[_Node]): ...
 
-_X = TypeVar("_X", bound=Hashable, covariant=True)
-_Y = TypeVar("_Y", bound=Hashable, covariant=True)
+_X_co = TypeVar("_X_co", bound=Hashable, covariant=True)
+_Y_co = TypeVar("_Y_co", bound=Hashable, covariant=True)
 
 @_dispatchable
-def compose(G: Graph[_X], H: Graph[_Y]) -> DiGraph[_X | _Y]: ...
+def compose(G: Graph[_X_co], H: Graph[_Y_co]) -> DiGraph[_X_co | _Y_co]: ...
 @_dispatchable
-def union(G: Graph[_X], H: Graph[_Y], rename: Iterable[Incomplete] | None = ()) -> DiGraph[_X | _Y]: ...
+def union(G: Graph[_X_co], H: Graph[_Y_co], rename: Iterable[Incomplete] | None = ()) -> DiGraph[_X_co | _Y_co]: ...

stubs/pynput/pynput/_util.pyi

@@ -7,7 +7,7 @@ from typing import Any, ClassVar, Generic, TypedDict, TypeVar
 from typing_extensions import ParamSpec, Self
 
 _T = TypeVar("_T")
-_AbstractListener_T = TypeVar("_AbstractListener_T", bound=AbstractListener)
+_AbstractListenerT = TypeVar("_AbstractListenerT", bound=AbstractListener)
 _P = ParamSpec("_P")
 
 class _RESOLUTIONS(TypedDict):
@@ -49,15 +49,15 @@ class AbstractListener(threading.Thread):
     def _stop_platform(self) -> None: ...  # undocumented
     def join(self, timeout: float | None = None, *args: Any) -> None: ...
 
-class Events(Generic[_T, _AbstractListener_T]):
-    _Listener: type[_AbstractListener_T] | None  # undocumented
+class Events(Generic[_T, _AbstractListenerT]):
+    _Listener: type[_AbstractListenerT] | None  # undocumented
 
     class Event:
         def __eq__(self, other: object) -> bool: ...
 
     _event_queue: Queue[_T]  # undocumented
     _sentinel: object  # undocumented
-    _listener: _AbstractListener_T  # undocumented
+    _listener: _AbstractListenerT  # undocumented
     start: Callable[[], None]
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def __enter__(self) -> Self: ...

stubs/pyserial/serial/tools/miniterm.pyi

@@ -8,10 +8,10 @@ from typing_extensions import Self
 
 from serial import Serial
 
-_AnyStr_T = TypeVar("_AnyStr_T", contravariant=True)
+_AnyStrT_contra = TypeVar("_AnyStrT_contra", contravariant=True)
 
 @type_check_only
-class _SupportsWriteAndFlush(SupportsWrite[_AnyStr_T], SupportsFlush, Protocol): ...
+class _SupportsWriteAndFlush(SupportsWrite[_AnyStrT_contra], SupportsFlush, Protocol): ...
 
 @type_check_only
 class _SupportsRead(Protocol):