Source code
from __future__ import annotations
import abc
import contextlib
import enum
import itertools
import linecache
import sys
import types
import unicodedata
import weakref
from collections.abc import Callable, Mapping
from functools import cached_property
from typing import Any, NamedTuple, TypeVar
from . import _compat, _config, setters
from ._compat import (
PY_3_11_PLUS, PY_3_13_PLUS,
_AnnotationExtractor,
_get_annotations,
_lazy_is_generator, get_generic_base,
)
from .exceptions import ( DefaultAlreadySetError,
FrozenInstanceError, NotAnAttrsClassError,
UnannotatedAttributeError, )
class _CacheHashWrapper(int):
"""
An integer subclass that pickles / copies as None
This is used for non-slots classes with ``cache_hash=True``, to avoid
serializing a potentially (even likely) invalid hash value. Since `None`
is the default value for uncalculated hashes, whenever this is copied,
the copy's value for the hash should automatically reset.
See GH #613 for more details.
"""
def __reduce__(self, _none_constructor=type(None), _args=()): # noqa: B008
return _none_constructor, _args
Run 1
The code demonstrates good readability: it has clear logical organization with imports grouped by type (stdlib, third-party, local). The class has a focused, single responsibility with good documentation explaining the 'why' behind its design. Nesting is minimal, and action granularity is generally one operation per line. However, some readability issues reduce the score: the import formatting is inconsistent in a few places (e.g., 'PY_3_11_PLUS, PY_3_13_PLUS,' and 'FrozenInstanceError, NotAnAttrsClassError,') with excessive spacing, and the exception import includes a trailing comma. The `__reduce__` method uses default arguments for performance optimization, which may seem unusual to readers without the explained context. The use of `# noqa: B008` is helpful for linters but could confuse developers unfamiliar with the convention. Overall, the code is professional, well-documented, and maintainable, but slight formatting inconsistencies prevent a higher score.
Run 2
The code demonstrates reasonable structure with clear imports, a well-defined class, and a descriptive docstring. However, there are several readability issues: the import statements are inconsistently formatted and overly lengthy, with multiple names crammed onto single lines; the __reduce__ method signature is cramped and includes an unconventional default argument pattern; and the overall organization, while functional, lacks the clean vertical spacing and consistent grouping that would make it more scannable. The class purpose is clear, and the docstring is helpful, but the action granularity is inconsistent—some lines contain multiple related items while others are properly separated. Nesting is minimal, which is positive. The reading flow is moderately good but could be improved with more systematic import organization and cleaner method signatures.
Run 3
The code is generally clear and well-structured. It uses imports, base classes, and docstrings effectively. The `_CacheHashWrapper` class has a clear purpose. However, the import formatting is awkward with inconsistent alignment and unnecessary vertical spacing, which slightly hurts readability. The multi-line imports could be consolidated. The `__reduce__` method has default arguments for optimization, which is a bit unusual but documented via comments. Overall, intent is clear and nesting is minimal, but the import section feels cluttered and the alignment choices are distracting rather than helpful.
Run 1
Code Structure: Imports precede a single, focused class, giving the snippet a logical organization, though grouped imports have inconsistent spacing. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name and detailed docstring clearly explain why cached hashes reset during copying or pickling; the special-method defaults are less immediately intuitive. Code length: The implementation is concise, with documentation providing useful context rather than unnecessary complexity. Action granularity: Each statement performs a single action, and the return expression is straightforward. Reading flow: The progression from imports to documentation to implementation is natural, but irregular import formatting and limited separation between sections slightly reduce readability.
Run 2
Code Structure: Imports precede a focused class, providing logical organization, though inconsistent import formatting adds clutter. Nesting: The class contains one short method with no nested control flow. Clarity of intent: The descriptive class name and docstring clearly explain why cached hashes reset during copying or pickling; the specialized __reduce__ defaults require some Python knowledge. Code length: The implementation is concise, with documentation proportionate to its non-obvious behavior. Action granularity: Statements perform one action each, although several imported names share awkwardly spaced lines. Reading flow: The progression from imports to documentation to implementation is natural, but irregular spacing and grouped imports slightly disrupt scanning.
Run 3
Code Structure: Imports and a single focused class are logically organized, though inconsistent import formatting reduces polish. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name and detailed docstring clearly explain why cached hashes reset during copying or pickling; the specialized __reduce__ signature requires some Python knowledge. Code length: The implementation is concise, and the explanatory docstring is justified by the non-obvious behavior. Action granularity: The method performs one clear return operation, although several imported names share awkwardly spaced lines. Reading flow: The progression from imports to class documentation to implementation is natural, but irregular spacing, crowded import lists, and limited separation between sections mildly disrupt readability.