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 demonstrates clear structure with a logical import organization, separating standard library, third-party, and local imports. It uses modern Python features (from __future__ import annotations, abc, enum imports) appropriately. The single class _CacheHashWrapper has a clear docstring explaining its purpose and includes a reference to the relevant issue. The class implementation is minimal and focused - it inherits from int, overrides __reduce__ with a documented technique using default arguments to avoid B008 lint issues. Type hints are used consistently. The code is flat with no deep nesting and each action is on its own line. The docstring length is appropriate for the complexity of the concept. Minor deductions: the noqa comment and the `_args=()` default argument pattern may be slightly cryptic for less experienced developers, and some imported modules (abc, contextlib, enum, etc.) appear unused in this snippet, though this is likely part of a larger module. Overall, this is well-structured, readable code with clear intent.
Run 3
The code demonstrates reasonable readability with some minor concerns. The structure is logical and imports are organized into groups (stdlib, third-party, local) with clear naming. The class `_CacheHashWrapper` has a clear purpose documented by a docstring explaining the caching behavior. Nesting is minimal, and action granularity is good with one significant operation per line. However, the code loses points for clarity of intent in the `__reduce__` method, where `_none_constructor` and `_args` default parameters feel like an obscure workaround (hence the noqa comment). The import block is lengthy and could be considered verbose for the remaining code snippet. Reading flow is generally natural but the parameter names like `_none_constructor` and the B008 suppression signal underlying complexity that isn't self-evident. The code is functional and maintainable but could benefit from a comment explaining why the reduce workaround exists beyond what the docstring offers.
Run 1
Code Structure: Imports are grouped coherently, followed by a small, focused class. Nesting: Minimal nesting makes the implementation easy to scan. Clarity of intent: The descriptive class name and detailed docstring clearly explain why cached hashes reset during copying or pickling; the special-method signature requires some Python knowledge. Code length: The implementation is concise, although the extensive imports are disproportionate to the shown functionality. Action granularity: Each statement performs one action, and the return expression is straightforward. Reading flow: The progression from imports to explanation to implementation is natural, though slightly more spacing between import groups and the class would improve visual separation.
Run 2
Code Structure: Imports are grouped logically, followed by a focused class, although many imports are unused in this excerpt. Nesting: The code is shallow, with only a class and its method. Clarity of intent: The descriptive class name and detailed docstring clearly explain why cached hashes reset during copying or pickling; the special-method signature and captured defaults require some Python knowledge. Code length: The implementation is concise, and the longer docstring provides useful context rather than unnecessary detail. Action granularity: Each line performs a single clear action. Reading flow: The progression from imports to explanation to implementation is natural, though the large import block relative to the small implementation and limited spacing between import groups slightly reduce readability.
Run 3
Code Structure: Imports precede a focused class with a single method, providing clear organization, though import grouping could be spaced better. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name and detailed docstring 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 extensive imports are unused in this excerpt. Action granularity: Each statement performs one clear action. Reading flow: The progression from imports to explanation to implementation is natural, with the long import section slightly delaying the relevant logic.