PY-59198 Update attr package stubs in test data

GitOrigin-RevId: 1292ba4fb7f39a2980b30c80d16811060f11509c

python/testData/inspections/PyDataclassInspection/attrsHelpersArgument.py

@@ -25,8 +25,8 @@ attrs.fields(<warning descr="'attr.fields' method should be called on attrs type
 attrs.fields_dict(<warning descr="'attr.fields_dict' method should be called on attrs types">A</warning>)
 attrs.fields_dict(<warning descr="'attr.fields_dict' method should be called on attrs types">A()</warning>)
 
-attrs.asdict(<warning descr="'attrs.asdict' method should be called on attrs instances">A()</warning>)
+attrs.asdict(<warning descr="'attr.asdict' method should be called on attrs instances">A()</warning>)
-attrs.astuple(<warning descr="'attrs.astuple' method should be called on attrs instances">A()</warning>)
+attrs.astuple(<warning descr="'attr.astuple' method should be called on attrs instances">A()</warning>)
 attrs.assoc(<warning descr="'attr.assoc' method should be called on attrs instances">A()</warning>)
 attrs.evolve(<warning descr="'attr.evolve' method should be called on attrs instances">A()</warning>)
 
@@ -69,8 +69,8 @@ attrs.astuple(B2())
 attrs.assoc(B2())
 attrs.evolve(B2())
 
-attrs.asdict(<warning descr="'attrs.asdict' method should be called on attrs instances">B2</warning>)
+attrs.asdict(<warning descr="'attr.asdict' method should be called on attrs instances">B2</warning>)
-attrs.astuple(<warning descr="'attrs.astuple' method should be called on attrs instances">B2</warning>)
+attrs.astuple(<warning descr="'attr.astuple' method should be called on attrs instances">B2</warning>)
 attrs.assoc(<warning descr="'attr.assoc' method should be called on attrs instances">B2</warning>)
 attrs.evolve(<warning descr="'attr.evolve' method should be called on attrs instances">B2</warning>)
 

python/testData/packages/attr/__init__.pyi

@@ -1,20 +1,14 @@
+import enum
 import sys
 
 from typing import (
     Any,
     Callable,
-    ClassVar,
-    Dict,
     Generic,
-    List,
     Mapping,
-    Optional,
     Protocol,
     Sequence,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -25,7 +19,32 @@ from . import filters as filters
 from . import setters as setters
 from . import validators as validators
 from ._cmp import cmp_using as cmp_using
+from ._typing_compat import AttrsInstance_
 from ._version_info import VersionInfo
+from attrs import (
+    define as define,
+    field as field,
+    mutable as mutable,
+    frozen as frozen,
+    _EqOrderType,
+    _ValidatorType,
+    _ConverterType,
+    _ReprArgType,
+    _OnSetAttrType,
+    _OnSetAttrArgType,
+    _FieldTransformer,
+    _ValidatorArgType,
+)
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+if sys.version_info >= (3, 11):
+    from typing import dataclass_transform
+else:
+    from typing_extensions import dataclass_transform
 
 __version__: str
 __version_info__: VersionInfo
@@ -41,90 +60,83 @@ __copyright__: str
 _T = TypeVar("_T")
 _C = TypeVar("_C", bound=type)
 
-_EqOrderType = Union[bool, Callable[[Any], Any]]
+_FilterType = Callable[["Attribute[_T]", _T], bool]
-_ValidatorType = Callable[[Any, Attribute[_T], _T], Any]
-_ConverterType = Callable[[Any], Any]
-_FilterType = Callable[[Attribute[_T], _T], bool]
-_ReprType = Callable[[Any], str]
-_ReprArgType = Union[bool, _ReprType]
-_OnSetAttrType = Callable[[Any, Attribute[Any], Any], Any]
-_OnSetAttrArgType = Union[
-    _OnSetAttrType, List[_OnSetAttrType], setters._NoOpType
-]
-_FieldTransformer = Callable[
-    [type, List[Attribute[Any]]], List[Attribute[Any]]
-]
-# FIXME: in reality, if multiple validators are passed they must be in a list
-# or tuple, but those are invariant and so would prevent subtypes of
-# _ValidatorType from working when passed in a list or tuple.
-_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
 
-# A protocol to be able to statically accept an attrs class.
+# We subclass this here to keep the protocol's qualified name clean.
-class AttrsInstance(Protocol):
+class AttrsInstance(AttrsInstance_, Protocol):
-    __attrs_attrs__: ClassVar[Any]
+    pass
 
-# _make --
+_A = TypeVar("_A", bound=type[AttrsInstance])
 
-NOTHING: object
+class _Nothing(enum.Enum):
+    NOTHING = enum.auto()
+
+NOTHING = _Nothing.NOTHING
 
 # NOTE: Factory lies about its return type to make this possible:
 # `x: List[int] # = Factory(list)`
 # Work around mypy issue #4554 in the common case by using an overload.
-if sys.version_info >= (3, 8):
+from typing import Literal
-    from typing import Literal
+
+@overload
+def Factory(factory: Callable[[], _T]) -> _T: ...
+@overload
+def Factory(
+    factory: Callable[[Any], _T],
+    takes_self: Literal[True],
+) -> _T: ...
+@overload
+def Factory(
+    factory: Callable[[], _T],
+    takes_self: Literal[False],
+) -> _T: ...
+
+In = TypeVar("In")
+Out = TypeVar("Out")
+
+class Converter(Generic[In, Out]):
     @overload
-    def Factory(factory: Callable[[], _T]) -> _T: ...
+    def __init__(self, converter: Callable[[In], Out]) -> None: ...
     @overload
-    def Factory(
+    def __init__(
-        factory: Callable[[Any], _T],
+        self,
+        converter: Callable[[In, AttrsInstance, Attribute], Out],
+        *,
         takes_self: Literal[True],
-    ) -> _T: ...
+        takes_field: Literal[True],
+    ) -> None: ...
     @overload
-    def Factory(
+    def __init__(
-        factory: Callable[[], _T],
+        self,
-        takes_self: Literal[False],
+        converter: Callable[[In, Attribute], Out],
-    ) -> _T: ...
+        *,
-
+        takes_field: Literal[True],
-else:
+    ) -> None: ...
     @overload
-    def Factory(factory: Callable[[], _T]) -> _T: ...
+    def __init__(
-    @overload
+        self,
-    def Factory(
+        converter: Callable[[In, AttrsInstance], Out],
-        factory: Union[Callable[[Any], _T], Callable[[], _T]],
+        *,
-        takes_self: bool = ...,
+        takes_self: Literal[True],
-    ) -> _T: ...
+    ) -> None: ...
-
-# Static type inference support via __dataclass_transform__ implemented as per:
-# https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md
-# This annotation must be applied to all overloads of "define" and "attrs"
-#
-# NOTE: This is a typing construct and does not exist at runtime.  Extensions
-# wrapping attrs decorators should declare a separate __dataclass_transform__
-# signature in the extension module using the specification linked above to
-# provide pyright support.
-def __dataclass_transform__(
-    *,
-    eq_default: bool = True,
-    order_default: bool = False,
-    kw_only_default: bool = False,
-    field_descriptors: Tuple[Union[type, Callable[..., Any]], ...] = (()),
-) -> Callable[[_T], _T]: ...
 
 class Attribute(Generic[_T]):
     name: str
-    default: Optional[_T]
+    default: _T | None
-    validator: Optional[_ValidatorType[_T]]
+    validator: _ValidatorType[_T] | None
     repr: _ReprArgType
     cmp: _EqOrderType
     eq: _EqOrderType
     order: _EqOrderType
-    hash: Optional[bool]
+    hash: bool | None
     init: bool
-    converter: Optional[_ConverterType]
+    converter: _ConverterType | Converter[Any, _T] | None
-    metadata: Dict[Any, Any]
+    metadata: dict[Any, Any]
-    type: Optional[Type[_T]]
+    type: type[_T] | None
     kw_only: bool
     on_setattr: _OnSetAttrType
+    alias: str | None
+
     def evolve(self, **changes: Any) -> "Attribute[Any]": ...
 
 # NOTE: We had several choices for the annotation to use for type arg:
@@ -156,17 +168,18 @@ def attrib(
     default: None = ...,
     validator: None = ...,
     repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
+    metadata: Mapping[Any, Any] | None = ...,
     type: None = ...,
     converter: None = ...,
     factory: None = ...,
     kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
 ) -> Any: ...
 
 # This form catches an explicit None or no default and infers the type from the
@@ -174,138 +187,70 @@ def attrib(
 @overload
 def attrib(
     default: None = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
+    validator: _ValidatorArgType[_T] | None = ...,
     repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
+    metadata: Mapping[Any, Any] | None = ...,
-    type: Optional[Type[_T]] = ...,
+    type: type[_T] | None = ...,
-    converter: Optional[_ConverterType] = ...,
+    converter: _ConverterType | Converter[Any, _T] | None = ...,
-    factory: Optional[Callable[[], _T]] = ...,
+    factory: Callable[[], _T] | None = ...,
     kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
 ) -> _T: ...
 
 # This form catches an explicit default argument.
 @overload
 def attrib(
     default: _T,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
+    validator: _ValidatorArgType[_T] | None = ...,
     repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
+    metadata: Mapping[Any, Any] | None = ...,
-    type: Optional[Type[_T]] = ...,
+    type: type[_T] | None = ...,
-    converter: Optional[_ConverterType] = ...,
+    converter: _ConverterType | Converter[Any, _T] | None = ...,
-    factory: Optional[Callable[[], _T]] = ...,
+    factory: Callable[[], _T] | None = ...,
     kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
 ) -> _T: ...
 
 # This form covers type=non-Type: e.g. forward references (str), Any
 @overload
 def attrib(
-    default: Optional[_T] = ...,
+    default: _T | None = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
+    validator: _ValidatorArgType[_T] | None = ...,
     repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
+    metadata: Mapping[Any, Any] | None = ...,
     type: object = ...,
-    converter: Optional[_ConverterType] = ...,
+    converter: _ConverterType | Converter[Any, _T] | None = ...,
-    factory: Optional[Callable[[], _T]] = ...,
+    factory: Callable[[], _T] | None = ...,
     kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
 ) -> Any: ...
 @overload
-def field(
+@dataclass_transform(order_default=True, field_specifiers=(attrib, field))
-    *,
-    default: None = ...,
-    validator: None = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: None = ...,
-    factory: None = ...,
-    kw_only: bool = ...,
-    eq: Optional[bool] = ...,
-    order: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> Any: ...
-
-# This form catches an explicit None or no default and infers the type from the
-# other arguments.
-@overload
-def field(
-    *,
-    default: None = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> _T: ...
-
-# This form catches an explicit default argument.
-@overload
-def field(
-    *,
-    default: _T,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> _T: ...
-
-# This form covers type=non-Type: e.g. forward references (str), Any
-@overload
-def field(
-    *,
-    default: Optional[_T] = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> Any: ...
-@overload
-@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
 def attrs(
     maybe_cls: _C,
-    these: Optional[Dict[str, Any]] = ...,
+    these: dict[str, Any] | None = ...,
-    repr_ns: Optional[str] = ...,
+    repr_ns: str | None = ...,
     repr: bool = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
     slots: bool = ...,
     frozen: bool = ...,
@@ -315,24 +260,25 @@ def attrs(
     kw_only: bool = ...,
     cache_hash: bool = ...,
     auto_exc: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
     auto_detect: bool = ...,
     collect_by_mro: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
+    getstate_setstate: bool | None = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
+    field_transformer: _FieldTransformer | None = ...,
     match_args: bool = ...,
+    unsafe_hash: bool | None = ...,
 ) -> _C: ...
 @overload
-@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
+@dataclass_transform(order_default=True, field_specifiers=(attrib, field))
 def attrs(
     maybe_cls: None = ...,
-    these: Optional[Dict[str, Any]] = ...,
+    these: dict[str, Any] | None = ...,
-    repr_ns: Optional[str] = ...,
+    repr_ns: str | None = ...,
     repr: bool = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
     slots: bool = ...,
     frozen: bool = ...,
@@ -342,90 +288,39 @@ def attrs(
     kw_only: bool = ...,
     cache_hash: bool = ...,
     auto_exc: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
     auto_detect: bool = ...,
     collect_by_mro: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
+    getstate_setstate: bool | None = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
+    field_transformer: _FieldTransformer | None = ...,
     match_args: bool = ...,
+    unsafe_hash: bool | None = ...,
 ) -> Callable[[_C], _C]: ...
-@overload
+def fields(cls: type[AttrsInstance]) -> Any: ...
-@__dataclass_transform__(field_descriptors=(attrib, field))
+def fields_dict(cls: type[AttrsInstance]) -> dict[str, Attribute[Any]]: ...
-def define(
-    maybe_cls: _C,
-    *,
-    these: Optional[Dict[str, Any]] = ...,
-    repr: bool = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[bool] = ...,
-    order: Optional[bool] = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-    match_args: bool = ...,
-) -> _C: ...
-@overload
-@__dataclass_transform__(field_descriptors=(attrib, field))
-def define(
-    maybe_cls: None = ...,
-    *,
-    these: Optional[Dict[str, Any]] = ...,
-    repr: bool = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[bool] = ...,
-    order: Optional[bool] = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-    match_args: bool = ...,
-) -> Callable[[_C], _C]: ...
-
-mutable = define
-frozen = define  # they differ only in their defaults
-
-def fields(cls: Type[AttrsInstance]) -> Any: ...
-def fields_dict(cls: Type[AttrsInstance]) -> Dict[str, Attribute[Any]]: ...
 def validate(inst: AttrsInstance) -> None: ...
 def resolve_types(
-    cls: _C,
+    cls: _A,
-    globalns: Optional[Dict[str, Any]] = ...,
+    globalns: dict[str, Any] | None = ...,
-    localns: Optional[Dict[str, Any]] = ...,
+    localns: dict[str, Any] | None = ...,
-    attribs: Optional[List[Attribute[Any]]] = ...,
+    attribs: list[Attribute[Any]] | None = ...,
-) -> _C: ...
+    include_extras: bool = ...,
+) -> _A: ...
 
 # TODO: add support for returning a proper attrs class from the mypy plugin
 # we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
 # [attr.ib()])` is valid
 def make_class(
     name: str,
-    attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+    attrs: list[str] | tuple[str, ...] | dict[str, Any],
-    bases: Tuple[type, ...] = ...,
+    bases: tuple[type, ...] = ...,
-    repr_ns: Optional[str] = ...,
+    class_body: dict[str, Any] | None = ...,
+    repr_ns: str | None = ...,
     repr: bool = ...,
-    cmp: Optional[_EqOrderType] = ...,
+    cmp: _EqOrderType | None = ...,
-    hash: Optional[bool] = ...,
+    hash: bool | None = ...,
     init: bool = ...,
     slots: bool = ...,
     frozen: bool = ...,
@@ -435,11 +330,11 @@ def make_class(
     kw_only: bool = ...,
     cache_hash: bool = ...,
     auto_exc: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
+    eq: _EqOrderType | None = ...,
-    order: Optional[_EqOrderType] = ...,
+    order: _EqOrderType | None = ...,
     collect_by_mro: bool = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
+    field_transformer: _FieldTransformer | None = ...,
 ) -> type: ...
 
 # _funcs --
@@ -453,24 +348,22 @@ def make_class(
 def asdict(
     inst: AttrsInstance,
     recurse: bool = ...,
-    filter: Optional[_FilterType[Any]] = ...,
+    filter: _FilterType[Any] | None = ...,
-    dict_factory: Type[Mapping[Any, Any]] = ...,
+    dict_factory: type[Mapping[Any, Any]] = ...,
     retain_collection_types: bool = ...,
-    value_serializer: Optional[
+    value_serializer: Callable[[type, Attribute[Any], Any], Any] | None = ...,
-        Callable[[type, Attribute[Any], Any], Any]
+    tuple_keys: bool | None = ...,
-    ] = ...,
+) -> dict[str, Any]: ...
-    tuple_keys: Optional[bool] = ...,
-) -> Dict[str, Any]: ...
 
 # TODO: add support for returning NamedTuple from the mypy plugin
 def astuple(
     inst: AttrsInstance,
     recurse: bool = ...,
-    filter: Optional[_FilterType[Any]] = ...,
+    filter: _FilterType[Any] | None = ...,
-    tuple_factory: Type[Sequence[Any]] = ...,
+    tuple_factory: type[Sequence[Any]] = ...,
     retain_collection_types: bool = ...,
-) -> Tuple[Any, ...]: ...
+) -> tuple[Any, ...]: ...
-def has(cls: type) -> bool: ...
+def has(cls: type) -> TypeGuard[type[AttrsInstance]]: ...
 def assoc(inst: _T, **changes: Any) -> _T: ...
 def evolve(inst: _T, **changes: Any) -> _T: ...
 

python/testData/packages/attr/_cmp.pyi

@@ -1,13 +1,13 @@
-from typing import Any, Callable, Optional, Type
+from typing import Any, Callable
 
 _CompareWithType = Callable[[Any, Any], bool]
 
 def cmp_using(
-    eq: Optional[_CompareWithType],
+    eq: _CompareWithType | None = ...,
-    lt: Optional[_CompareWithType],
+    lt: _CompareWithType | None = ...,
-    le: Optional[_CompareWithType],
+    le: _CompareWithType | None = ...,
-    gt: Optional[_CompareWithType],
+    gt: _CompareWithType | None = ...,
-    ge: Optional[_CompareWithType],
+    ge: _CompareWithType | None = ...,
-    require_same_type: bool,
+    require_same_type: bool = ...,
-    class_name: str,
+    class_name: str = ...,
-) -> Type: ...
+) -> type: ...

python/testData/packages/attr/_typing_compat.pyi

@@ -0,0 +1,15 @@
+from typing import Any, ClassVar, Protocol
+
+# MYPY is a special constant in mypy which works the same way as `TYPE_CHECKING`.
+MYPY = False
+
+if MYPY:
+    # A protocol to be able to statically accept an attrs class.
+    class AttrsInstance_(Protocol):
+        __attrs_attrs__: ClassVar[Any]
+
+else:
+    # For type checkers without plug-in support use an empty protocol that
+    # will (hopefully) be combined into a union.
+    class AttrsInstance_(Protocol):
+        pass

python/testData/packages/attr/converters.pyi

@@ -1,6 +1,6 @@
-from typing import Callable, Optional, TypeVar, overload
+from typing import Callable, TypeVar, overload
 
-from . import _ConverterType
+from attrs import _ConverterType
 
 _T = TypeVar("_T")
 

python/testData/packages/attr/filters.pyi

@@ -1,6 +1,6 @@
-from typing import Any, Union
+from typing import Any
 
 from . import Attribute, _FilterType
 
-def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
+def include(*what: type | str | Attribute[Any]) -> _FilterType[Any]: ...
-def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
+def exclude(*what: type | str | Attribute[Any]) -> _FilterType[Any]: ...

python/testData/packages/attr/setters.pyi

@@ -1,6 +1,7 @@
-from typing import Any, NewType, NoReturn, TypeVar, cast
+from typing import Any, NewType, NoReturn, TypeVar
 
-from . import Attribute, _OnSetAttrType
+from . import Attribute
+from attrs import _OnSetAttrType
 
 _T = TypeVar("_T")
 

python/testData/packages/attr/validators.pyi

@@ -5,20 +5,15 @@ from typing import (
     Container,
     ContextManager,
     Iterable,
-    List,
     Mapping,
     Match,
-    Optional,
     Pattern,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
     overload,
 )
 
-from . import _ValidatorType
+from attrs import _ValidatorType
-from . import _ValidatorArgType
+from attrs import _ValidatorArgType
 
 _T = TypeVar("_T")
 _T1 = TypeVar("_T1")
@@ -36,40 +31,41 @@ def disabled() -> ContextManager[None]: ...
 # To be more precise on instance_of use some overloads.
 # If there are more than 3 items in the tuple then we fall back to Any
 @overload
-def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ...
+def instance_of(type: type[_T]) -> _ValidatorType[_T]: ...
 @overload
-def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ...
+def instance_of(type: tuple[type[_T]]) -> _ValidatorType[_T]: ...
 @overload
 def instance_of(
-    type: Tuple[Type[_T1], Type[_T2]]
+    type: tuple[type[_T1], type[_T2]],
-) -> _ValidatorType[Union[_T1, _T2]]: ...
+) -> _ValidatorType[_T1 | _T2]: ...
 @overload
 def instance_of(
-    type: Tuple[Type[_T1], Type[_T2], Type[_T3]]
+    type: tuple[type[_T1], type[_T2], type[_T3]],
-) -> _ValidatorType[Union[_T1, _T2, _T3]]: ...
+) -> _ValidatorType[_T1 | _T2 | _T3]: ...
 @overload
-def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ...
+def instance_of(type: tuple[type, ...]) -> _ValidatorType[Any]: ...
-def provides(interface: Any) -> _ValidatorType[Any]: ...
 def optional(
-    validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]
+    validator: (
-) -> _ValidatorType[Optional[_T]]: ...
+        _ValidatorType[_T]
+        | list[_ValidatorType[_T]]
+        | tuple[_ValidatorType[_T]]
+    ),
+) -> _ValidatorType[_T | None]: ...
 def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
 def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
 def matches_re(
-    regex: Union[Pattern[AnyStr], AnyStr],
+    regex: Pattern[AnyStr] | AnyStr,
     flags: int = ...,
-    func: Optional[
+    func: Callable[[AnyStr, AnyStr, int], Match[AnyStr] | None] | None = ...,
-        Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]]
-    ] = ...,
 ) -> _ValidatorType[AnyStr]: ...
 def deep_iterable(
     member_validator: _ValidatorArgType[_T],
-    iterable_validator: Optional[_ValidatorType[_I]] = ...,
+    iterable_validator: _ValidatorType[_I] | None = ...,
 ) -> _ValidatorType[_I]: ...
 def deep_mapping(
     key_validator: _ValidatorType[_K],
     value_validator: _ValidatorType[_V],
-    mapping_validator: Optional[_ValidatorType[_M]] = ...,
+    mapping_validator: _ValidatorType[_M] | None = ...,
 ) -> _ValidatorType[_M]: ...
 def is_callable() -> _ValidatorType[_T]: ...
 def lt(val: _T) -> _ValidatorType[_T]: ...
@@ -78,3 +74,10 @@ def ge(val: _T) -> _ValidatorType[_T]: ...
 def gt(val: _T) -> _ValidatorType[_T]: ...
 def max_len(length: int) -> _ValidatorType[_T]: ...
 def min_len(length: int) -> _ValidatorType[_T]: ...
+def not_(
+    validator: _ValidatorType[_T],
+    *,
+    msg: str | None = None,
+    exc_types: type[Exception] | Iterable[type[Exception]] = ...,
+) -> _ValidatorType[_T]: ...
+def or_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...

python/testData/packages/attrs/__init__.pyi

@@ -1,12 +1,12 @@
+import sys
+
 from typing import (
     Any,
     Callable,
-    Dict,
     Mapping,
-    Optional,
     Sequence,
-    Tuple,
+    overload,
-    Type,
+    TypeVar,
 )
 
 # Because we need to type our own stuff, we have to make everything from
@@ -20,47 +20,233 @@ from attr import __title__ as __title__
 from attr import __url__ as __url__
 from attr import __version__ as __version__
 from attr import __version_info__ as __version_info__
-from attr import _FilterType
 from attr import assoc as assoc
 from attr import Attribute as Attribute
+from attr import AttrsInstance as AttrsInstance
 from attr import cmp_using as cmp_using
 from attr import converters as converters
-from attr import define as define
+from attr import Converter as Converter
 from attr import evolve as evolve
 from attr import exceptions as exceptions
 from attr import Factory as Factory
-from attr import field as field
 from attr import fields as fields
 from attr import fields_dict as fields_dict
 from attr import filters as filters
-from attr import frozen as frozen
 from attr import has as has
 from attr import make_class as make_class
-from attr import mutable as mutable
 from attr import NOTHING as NOTHING
 from attr import resolve_types as resolve_types
 from attr import setters as setters
 from attr import validate as validate
 from attr import validators as validators
+from attr import attrib, asdict as asdict, astuple as astuple
 
-# TODO: see definition of attr.asdict/astuple
+if sys.version_info >= (3, 11):
-def asdict(
+    from typing import dataclass_transform
-    inst: Any,
+else:
-    recurse: bool = ...,
+    from typing_extensions import dataclass_transform
-    filter: Optional[_FilterType[Any]] = ...,
-    dict_factory: Type[Mapping[Any, Any]] = ...,
-    retain_collection_types: bool = ...,
-    value_serializer: Optional[
-        Callable[[type, Attribute[Any], Any], Any]
-    ] = ...,
-    tuple_keys: bool = ...,
-) -> Dict[str, Any]: ...
 
-# TODO: add support for returning NamedTuple from the mypy plugin
+_T = TypeVar("_T")
-def astuple(
+_C = TypeVar("_C", bound=type)
-    inst: Any,
+
-    recurse: bool = ...,
+_EqOrderType = bool | Callable[[Any], Any]
-    filter: Optional[_FilterType[Any]] = ...,
+_ValidatorType = Callable[[Any, "Attribute[_T]", _T], Any]
-    tuple_factory: Type[Sequence[Any]] = ...,
+_ConverterType = Callable[[Any], Any]
-    retain_collection_types: bool = ...,
+_ReprType = Callable[[Any], str]
-) -> Tuple[Any, ...]: ...
+_ReprArgType = bool | _ReprType
+_OnSetAttrType = Callable[[Any, "Attribute[Any]", Any], Any]
+_OnSetAttrArgType = _OnSetAttrType | list[_OnSetAttrType] | setters._NoOpType
+_FieldTransformer = Callable[
+    [type, list["Attribute[Any]"]], list["Attribute[Any]"]
+]
+# FIXME: in reality, if multiple validators are passed they must be in a list
+# or tuple, but those are invariant and so would prevent subtypes of
+# _ValidatorType from working when passed in a list or tuple.
+_ValidatorArgType = _ValidatorType[_T] | Sequence[_ValidatorType[_T]]
+
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    metadata: Mapping[Any, Any] | None = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: bool | None = ...,
+    order: bool | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
+    type: type | None = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: _ValidatorArgType[_T] | None = ...,
+    repr: _ReprArgType = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    metadata: Mapping[Any, Any] | None = ...,
+    converter: _ConverterType | Converter[Any, _T] | None = ...,
+    factory: Callable[[], _T] | None = ...,
+    kw_only: bool = ...,
+    eq: _EqOrderType | None = ...,
+    order: _EqOrderType | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
+    type: type | None = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def field(
+    *,
+    default: _T,
+    validator: _ValidatorArgType[_T] | None = ...,
+    repr: _ReprArgType = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    metadata: Mapping[Any, Any] | None = ...,
+    converter: _ConverterType | Converter[Any, _T] | None = ...,
+    factory: Callable[[], _T] | None = ...,
+    kw_only: bool = ...,
+    eq: _EqOrderType | None = ...,
+    order: _EqOrderType | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
+    type: type | None = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def field(
+    *,
+    default: _T | None = ...,
+    validator: _ValidatorArgType[_T] | None = ...,
+    repr: _ReprArgType = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    metadata: Mapping[Any, Any] | None = ...,
+    converter: _ConverterType | Converter[Any, _T] | None = ...,
+    factory: Callable[[], _T] | None = ...,
+    kw_only: bool = ...,
+    eq: _EqOrderType | None = ...,
+    order: _EqOrderType | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    alias: str | None = ...,
+    type: type | None = ...,
+) -> Any: ...
+@overload
+@dataclass_transform(field_specifiers=(attrib, field))
+def define(
+    maybe_cls: _C,
+    *,
+    these: dict[str, Any] | None = ...,
+    repr: bool = ...,
+    unsafe_hash: bool | None = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: bool | None = ...,
+    order: bool | None = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: bool | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    field_transformer: _FieldTransformer | None = ...,
+    match_args: bool = ...,
+) -> _C: ...
+@overload
+@dataclass_transform(field_specifiers=(attrib, field))
+def define(
+    maybe_cls: None = ...,
+    *,
+    these: dict[str, Any] | None = ...,
+    repr: bool = ...,
+    unsafe_hash: bool | None = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: bool | None = ...,
+    order: bool | None = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: bool | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    field_transformer: _FieldTransformer | None = ...,
+    match_args: bool = ...,
+) -> Callable[[_C], _C]: ...
+
+mutable = define
+
+@overload
+@dataclass_transform(frozen_default=True, field_specifiers=(attrib, field))
+def frozen(
+    maybe_cls: _C,
+    *,
+    these: dict[str, Any] | None = ...,
+    repr: bool = ...,
+    unsafe_hash: bool | None = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: bool | None = ...,
+    order: bool | None = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: bool | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    field_transformer: _FieldTransformer | None = ...,
+    match_args: bool = ...,
+) -> _C: ...
+@overload
+@dataclass_transform(frozen_default=True, field_specifiers=(attrib, field))
+def frozen(
+    maybe_cls: None = ...,
+    *,
+    these: dict[str, Any] | None = ...,
+    repr: bool = ...,
+    unsafe_hash: bool | None = ...,
+    hash: bool | None = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: bool | None = ...,
+    order: bool | None = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: bool | None = ...,
+    on_setattr: _OnSetAttrArgType | None = ...,
+    field_transformer: _FieldTransformer | None = ...,
+    match_args: bool = ...,
+) -> Callable[[_C], _C]: ...