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
This code is highly readable due to its clear structure and organization. The module imports are grouped logically: standard library imports first, then third-party/related modules, followed by local imports. The use of `from __future__ import annotations` at the top is a best practice. The `_CacheHashWrapper` class has a clear, descriptive name and includes a comprehensive docstring explaining its unusual behavior (pickling as None). The method `__reduce__` is concise and uses descriptive parameter names with helpful comments. Type hints are used appropriately throughout. The code avoids excessive nesting and maintains a flat structure. Each action is on its own line, and the overall reading flow is natural. Minor deductions for the slightly complex import structure and the `# noqa: B008` comment, which could benefit from additional context, but overall this is exemplary Python code that balances clarity with functionality.
Run 2
The code demonstrates clear structure with organized imports, a single class definition, and a focused docstring explaining the purpose. Nesting is minimal and flat, contributing to readability. The intent of the class is well-documented, and the code length is concise. Action granularity is appropriate — each line performs one logical operation. However, score is reduced because the reading flow is slightly interrupted by the `# noqa: B008` comment and default argument usage in the method signature, which may confuse unfamiliar readers. Additionally, the import block is long but acceptable for library code. Overall, the code is clear and maintainable with minor readability trade-offs related to style pragmatics.
Run 3
The code is well-structured with clear separation of imports, proper use of `__future__` annotations, and a documented class. Imports are grouped logically (stdlib, third-party, local), and the class has a clear purpose explained in a concise docstring. Nesting is minimal, with no deeply nested blocks. The class method `__reduce__` is implemented in one line but remains readable. Action granularity is appropriate, and reading flow is natural. Minor deductions: the use of `# noqa: B008` suggests a potential linting workaround, and the class name `_CacheHashWrapper` is slightly verbose but still clear. Overall, the code is highly readable.
Run 1
Code Structure: Imports are grouped before a small, focused class, providing clear organization. Nesting: Minimal nesting makes the implementation easy to follow. Clarity of intent: The descriptive class name and detailed docstring explain why cached hashes reset during copying or pickling; the specialized __reduce__ mechanism requires some Python knowledge. Code length: The implementation is concise, although the extensive imports appear disproportionate to the displayed functionality. Action granularity: Each statement performs one clear action. Reading flow: The progression from imports to documentation to implementation is natural, with only minor spacing limitations and specialized default arguments slowing comprehension.
Run 2
Code Structure: Imports are grouped logically, followed by a focused class, though many imports are unused in this excerpt. 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 serialization; the specialized __reduce__ signature requires some Python knowledge. Code length: The implementation is concise, and the documentation provides useful context without excessive detail. 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 class name and detailed docstring clearly explain why cached hashes reset during copying or pickling; the unusual default arguments in __reduce__ require some Python knowledge. Code length: The implementation is concise, though the extensive imports appear disproportionate to this excerpt. Action granularity: Each line performs a single clear action. Reading flow: The progression from imports to explanation to implementation is natural, with minor spacing improvements possible between import groups and the class.