Use internal mechanisms instead of NamedTuple

Mostly to prevent Mypy from looking at our code, but sadly it wasn't
enough courtesy of enums for some reason.

Author: hynek

docs/api.rst

@@ -197,10 +197,10 @@ Helpers
    .. doctest::
 
       >>> @define
-      ... class C:
+      ... class CInspect:
       ...     pass
-      >>> attrs.inspect(C)
-      ClassProps(is_exception=False, is_slotted=True, has_weakref_slot=True, is_frozen=False, kw_only=ClassProps.KeywordOnly.NO, collect_by_mro=False, init=True, repr=True, eq=True, order=True, hash=ClassProps.Hashability.UNHASHABLE, match_args=True, str=False, getstate_setstate=False, on_setattr=None, field_transformer=None)
+      >>> attrs.inspect(CInspect)  # doctest: +ELLIPSIS
+      ClassProps(is_exception=False, is_slotted=True, has_weakref_slot=True, is_frozen=False, kw_only=<KeywordOnly.NO: 'no'>, collect_by_mro=True, init=True, repr=True, eq=True, order=False, hash=<Hashability.UNHASHABLE: 'unhashable'>, match_args=True, str=False, getstate_setstate=True, on_setattr=<function pipe.<locals>.wrapped_pipe at ...>, field_transformer=None)
 
 .. autoclass:: attrs.ClassProps
 .. autoclass:: attrs.ClassProps.Hashability

src/attr/__init__.py

@@ -10,10 +10,11 @@
 from . import converters, exceptions, filters, setters, validators
 from ._cmp import cmp_using
 from ._config import get_run_validators, set_run_validators
-from ._funcs import asdict, assoc, astuple, has, resolve_types
+from ._funcs import asdict, assoc, astuple, has, inspect, resolve_types
 from ._make import (
     NOTHING,
     Attribute,
+    ClassProps,
     Converter,
     Factory,
     _Nothing,
@@ -26,7 +27,6 @@
     validate,
 )
 from ._next_gen import define, field, frozen, mutable
-from ._props import ClassProps, inspect
 from ._version_info import VersionInfo
 
 

src/attr/__init__.pyi

@@ -20,8 +20,7 @@ from . import filters as filters
 from . import setters as setters
 from . import validators as validators
 from ._cmp import cmp_using as cmp_using
-from ._funcs import inspect as inspect
-from ._props import ClassProps as ClassProps
+
 from ._typing_compat import AttrsInstance_
 from ._version_info import VersionInfo
 from attrs import (
@@ -142,6 +141,58 @@ class Attribute(Generic[_T]):
 
     def evolve(self, **changes: Any) -> "Attribute[Any]": ...
 
+class ClassProps:
+    """
+    XXX: somehow defining/using enums Mypy starts looking at our own code
+    and causes tons of errors.
+    """
+
+    # class Hashability(enum.Enum): ...
+    # class KeywordOnly(enum.Enum): ...
+
+    is_exception: bool
+    is_slotted: bool
+    has_weakref_slot: bool
+    is_frozen: bool
+    # kw_only: ClassProps.KeywordOnly
+    kw_only: Any
+    collect_by_mro: bool
+    init: bool
+    repr: bool
+    eq: bool
+    order: bool
+    # hash: ClassProps.Hashability
+    hash: Any
+    match_args: bool
+    str: bool
+    getstate_setstate: bool
+    on_setattr: _OnSetAttrType
+    field_transformer: Callable[[Attribute[Any]], Attribute[Any]]
+
+    def __init__(
+        self,
+        is_exception: bool,
+        is_slotted: bool,
+        has_weakref_slot: bool,
+        is_frozen: bool,
+        # kw_only: ClassProps.KeywordOnly
+        kw_only: Any,
+        collect_by_mro: bool,
+        init: bool,
+        repr: bool,
+        eq: bool,
+        order: bool,
+        # hash: ClassProps.Hashability
+        hash: Any,
+        match_args: bool,
+        str: bool,
+        getstate_setstate: bool,
+        on_setattr: _OnSetAttrType,
+        field_transformer: Callable[[Attribute[Any]], Attribute[Any]],
+    ) -> None: ...
+    @property
+    def is_hashable(self) -> bool: ...
+
 # NOTE: We had several choices for the annotation to use for type arg:
 # 1) Type[_T]
 #   - Pros: Handles simple cases correctly
@@ -376,6 +427,7 @@ def astuple(
     retain_collection_types: bool = ...,
 ) -> tuple[Any, ...]: ...
 def has(cls: type) -> TypeGuard[type[AttrsInstance]]: ...
+def inspect(cls: type) -> ClassProps: ...
 def assoc(inst: _T, **changes: Any) -> _T: ...
 def evolve(inst: _T, **changes: Any) -> _T: ...
 

src/attr/_funcs.py

@@ -5,7 +5,7 @@
 
 from ._compat import get_generic_base
 from ._make import _OBJ_SETATTR, NOTHING, fields
-from .exceptions import AttrsAttributeNotFoundError
+from .exceptions import AttrsAttributeNotFoundError, NotAnAttrsClassError
 
 
 _ATOMIC_TYPES = frozenset(
@@ -379,6 +379,28 @@ def has(cls):
     return False
 
 
+def inspect(cls):
+    """
+    Inspect the class and return it's effective build parameters.
+
+    Args:
+        cls: The class to inspect.
+
+    Returns:
+        The effective build parameters of the class.
+
+    Raises:
+        NotAnAttrsClassError: If the class is not an *attrs*-decorated class.
+
+    .. versionadded:: 25.4.0
+    """
+    try:
+        return cls.__dict__["__attrs_props__"]
+    except KeyError:
+        msg = f"{cls!r} is not an attrs-decorated class."
+        raise NotAnAttrsClassError(msg) from None
+
+
 def assoc(inst, **changes):
     """
     Copy *inst* and apply *changes*.

src/attr/_make.py

@@ -18,8 +18,6 @@
 from functools import cached_property
 from typing import Any, NamedTuple, TypeVar
 
-from attr._props import ClassProps
-
 # We need to import _compat itself in addition to the _compat members to avoid
 # having the thread-local in the globals here.
 from . import _compat, _config, setters
@@ -2798,6 +2796,127 @@ def default(self, meth):
 _CountingAttr = _add_eq(_add_repr(_CountingAttr))
 
 
+class ClassProps:
+    """
+    Effective class properties as derived from parameters to attr.s() or
+    define() decorators.
+
+    .. versionadded:: 25.4.0
+    """
+
+    class Hashability(enum.Enum):
+        """
+        The hashability of a class.
+
+        .. versionadded:: 25.4.0
+        """
+
+        HASHABLE = "hashable"
+        """Write a ``__hash__``."""
+        HASHABLE_CACHED = "hashable_cache"
+        """Write a ``__hash__`` and cache the hash."""
+        UNHASHABLE = "unhashable"
+        """Set ``__hash__`` to ``None``."""
+        LEAVE_ALONE = "leave_alone"
+        """Don't touch ``__hash__``."""
+
+    class KeywordOnly(enum.Enum):
+        """
+        How attributes should be treated regarding keyword-only parameters.
+
+        .. versionadded:: 25.4.0
+        """
+
+        NO = "no"
+        """Attributes are not keyword-only."""
+        YES = "yes"
+        """Attributes in current class without kw_only=False are keyword-only."""
+        FORCE = "force"
+        """All attributes are keyword-only."""
+
+    __slots__ = (  # noqa: RUF023 -- order matters for __init__
+        "is_exception",
+        "is_slotted",
+        "has_weakref_slot",
+        "is_frozen",
+        "kw_only",
+        "collect_by_mro",
+        "init",
+        "repr",
+        "eq",
+        "order",
+        "hash",
+        "match_args",
+        "str",
+        "getstate_setstate",
+        "on_setattr",
+        "field_transformer",
+    )
+
+    def __init__(
+        self,
+        is_exception,
+        is_slotted,
+        has_weakref_slot,
+        is_frozen,
+        kw_only,
+        collect_by_mro,
+        init,
+        repr,
+        eq,
+        order,
+        hash,
+        match_args,
+        str,
+        getstate_setstate,
+        on_setattr,
+        field_transformer,
+    ):
+        self.is_exception = is_exception
+        self.is_slotted = is_slotted
+        self.has_weakref_slot = has_weakref_slot
+        self.is_frozen = is_frozen
+        self.kw_only = kw_only
+        self.collect_by_mro = collect_by_mro
+        self.init = init
+        self.repr = repr
+        self.eq = eq
+        self.order = order
+        self.hash = hash
+        self.match_args = match_args
+        self.str = str
+        self.getstate_setstate = getstate_setstate
+        self.on_setattr = on_setattr
+        self.field_transformer = field_transformer
+
+    @property
+    def is_hashable(self):
+        return (
+            self.hash is ClassProps.Hashability.HASHABLE
+            or self.hash is ClassProps.Hashability.HASHABLE_CACHED
+        )
+
+
+_cas = [
+    Attribute(
+        name=name,
+        default=NOTHING,
+        validator=None,
+        repr=True,
+        cmp=None,
+        eq=True,
+        order=False,
+        hash=True,
+        init=True,
+        inherited=False,
+        alias=_default_init_alias_for(name),
+    )
+    for name in ClassProps.__slots__
+]
+
+ClassProps = _add_eq(_add_repr(ClassProps, attrs=_cas), attrs=_cas)
+
+
 class Factory:
     """
     Stores a factory callable.