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 is generally well-structured and readable. It demonstrates clear organization with logical import grouping (stdlib, third-party, local), explicit future annotations import, and a focused single-class definition. The class has a clear docstring explaining its purpose and non-obvious behavior, which significantly improves clarity. Nesting is flat with no conditional logic. Action granularity is appropriate - each line performs one clear operation. The reading flow is natural: imports, then class definition, then method. The use of type hints (int subclass, annotations) adds to clarity. Minor deductions: the import section is somewhat long but follows Python conventions. The default argument pattern (_none_constructor=type(None), _args=()) is slightly unconventional and may require readers to pause. The blanket noqa comment suppresses linting checks without specifying which rule is being disabled. Overall, this is readable code appropriate for a library implementation.
Run 2
The code is well-structured with clear separation of imports, a single class definition, and a concise docstring explaining non-obvious behavior. Nesting is minimal - the class has one method with no nested blocks. Intent is clearly documented through the class name, docstring, and method purpose. Code length is appropriate: the module header imports what's needed and the class implements focused functionality. Action granularity is good with each operation on its own line. Reading flow follows a natural progression from imports to class definition to method implementation. The only minor deductions are for the somewhat cryptic `__reduce__` implementation (though documented) and the `# noqa: B008` comment which assumes familiarity with linting rules.
Run 3
The code is well-structured and highly readable. Imports are organized logically, with clear separation between standard library, third-party, and local modules. The single class defined has a clear, documented purpose with a concise docstring explaining the rationale. Nesting is minimal — there is only one method with a single return statement. Intent is explicit through descriptive naming and comments referencing a GitHub issue for context. Code length is appropriate: no unnecessary verbosity or redundancy. Action granularity is good, with each line performing a distinct operation. The reading flow is natural, moving from imports to class definition to method details. Minor deductions: `_none_constructor` and `_args` as default arguments may be slightly opaque without deeper comprehension, and the import block is long. Overall, this code adheres to clean coding practices and is easy to follow.
Run 1
Code Structure: Imports are grouped logically, followed by a small, focused class. Nesting: Minimal nesting makes the implementation easy to scan. Clarity of intent: The class name and detailed 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, although the import block is large relative to the displayed functionality. Action granularity: Each import or operation occupies its own line, with a single return in the method. Reading flow: The progression from imports to documentation to implementation is natural, though an extra blank line before the top-level class would improve visual separation.
Run 2
Code Structure: Imports and the class are logically organized, though the extensive import block adds overhead to this small excerpt. Nesting: The code is flat, with only a class and a single method. Clarity of intent: The descriptive class name and detailed docstring clearly explain why cached hashes reset during copying and pickling; the specialized __reduce__ signature and captured defaults require some Python knowledge. Code length: The implementation is concise, and the documentation provides useful context rather than unnecessary repetition. Action granularity: Each statement performs a single clear action. Reading flow: The progression from imports to explanation to implementation is natural, although additional blank lines between import groups and before the class would improve visual separation.
Run 3
Code Structure: Imports are grouped logically, followed by a small, focused class. Nesting: Minimal nesting makes the implementation easy to scan. Clarity of intent: The descriptive class name and thorough docstring explain why cached hashes reset during copying or pickling, although the __reduce__ defaults require familiarity with Python serialization. Code length: The implementation is concise; the import list is substantial relative to the shown functionality. Action granularity: Each line performs one clear action, with a straightforward tuple return. Reading flow: The progression from imports to documentation to implementation is natural, though additional blank lines between import groups and before the class would improve visual separation.