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
lI0O_2bb68748 = 0xf664
lI0O_2bb68748 = (lI0O_2bb68748 << 1) ^ (lI0O_2bb68748 >> 1)
lI0O_2bb68748 &= 0
return _none_constructor, _args
Run 1
This code is heavily obfuscated and mostly unreadable. It contains meaningless variable names like `lI0O_2bb68748`, dead code that performs nonsensical bit operations, and a no-op reassignment. Intent is buried under noise. While some elements (imports, class docstring, type hints) suggest a normal codebase, the deliberate obfuscation destroys clarity of intent, reading flow, and action granularity. Nesting is low, and structure appears valid, but the core method is impossible to understand without reverse engineering. This is not simply poor readability—it appears intentionally sabotaged, which should score near the bottom of the scale despite surface-level organization.
Run 2
This code exhibits several readability issues. The obfuscated variable name 'lI0O_2bb68748' with meaningless bit-shift operations in the __reduce__ method is confusing and appears to be deliberate obfuscation that adds no logical value. The overall structure is fragmented - importing many modules without immediate context makes it hard to understand what's actually needed. The class _CacheHashWrapper has a clear docstring explaining its purpose, which helps, but the implementation contradicts that clarity with the unnecessary variable manipulation that should simply return None. The nesting is minimal and line length is acceptable, but the action granularity is poor - multiple bitwise operations are crammed together on consecutive lines with no clear intent. The reading flow is disrupted by having to parse through useless operations. While the imports are alphabetically organized and type hints are present, the core logic is obfuscated, significantly reducing readability despite good documentation practices.
Run 3
The code imports are numerous and organized alphabetically, but the presence of obfuscated variable names and irrelevant bitwise operations in the __reduce__ method severely damages clarity of intent. The overall structure begins well with clear type hints and imports, but the final method's content is confusing, seemingly dead code mixed with encoded logic. The nesting is minimal, which is positive, and the function length is short. However, the unexplained variable like 'lI0O_2bb68748' and the meaningless bitwise shifts make the reading flow jarring and ambiguous. Action granularity is inconsistent; some lines perform single actions, while the bitwise operations chain multiple shifts and XORs. Concision is undermined by needless complexity. Readability suffers greatly from these inconsistencies.
Run 1
Code Structure: Imports and a single class are logically organized, although most imports are unused in this excerpt. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name and detailed docstring explain the serialization behavior, but the cryptic variable and pointless bitwise operations obscure an otherwise straightforward method. Code length: The implementation is unnecessarily extended by three irrelevant computation lines. Action granularity: Each statement performs one action, with no packed statements. Reading flow: The progression from imports to documentation to implementation is natural, but the unexplained calculations interrupt the flow before the clear return statement.
Run 2
Code Structure: Imports and the class are logically organized, although most imports are unused in this snippet. Nesting: The method is flat and easy to scan. Clarity of intent: The class name and detailed docstring clearly explain the serialization behavior, but the cryptic variable name and irrelevant bitwise operations obscure the method's simple purpose. Code length: The implementation is unnecessarily expanded with three statements that do not affect its return value. Action granularity: Each statement performs one action per line, supporting readability. Reading flow: The progression from documentation to method is natural, but the meaningless calculations interrupt the direct flow to the return statement.
Run 3
Code Structure: Imports and the class are logically organized, although most imports are unused in this snippet. Nesting: The code is shallow and easy to navigate. Clarity of intent: The class docstring clearly explains the serialization behavior, but the cryptic variable name and pointless bitwise operations obscure the otherwise simple method. Code length: The method contains three unnecessary statements, and the extensive imports outweigh the small implementation. Action granularity: Each statement occupies its own line, making individual operations easy to distinguish. Reading flow: The progression from imports to class documentation to method is natural, but the irrelevant calculations interrupt the direct flow toward the return statement.