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 _Nothing(enum.Enum):
"""
Sentinel to indicate the lack of a value when `None` is ambiguous.
If extending attrs, you can use ``typing.Literal[NOTHING]`` to show
that a value may be ``NOTHING``.
.. versionchanged:: 21.1.0 ``bool(NOTHING)`` is now False.
.. versionchanged:: 22.2.0 ``NOTHING`` is now an ``enum.Enum`` variant.
"""
NOTHING = enum.auto()
def __repr__(self):
return "NOTHING"
def __bool__(self):
return False
Run 1
The code demonstrates strong readability through clear module organization with logical import grouping, a well-named sentinel class, and appropriate use of enums. The structure is flat with minimal nesting, making the control flow easy to follow. The class purpose is immediately apparent from the docstring, which also includes helpful version annotations. The implementation is concise, using enum.auto() appropriately, and each method contains a single clear action. The reading flow is natural, with imports organized by type (future, stdlib, typing, third-party) followed by the class definition. Minor deductions possible for the large number of imports without immediate context, but this is justified for a foundational module. The code follows idiomatic Python patterns and would be easily understood by experienced developers.
Run 2
The code is generally readable and well-structured. It uses clear imports, a sentinel enum with useful docstrings, and flat organization. Nesting is minimal, and intent is clear through naming and comments. However, the large number of imports reduces immediate clarity, and the use of conditional/version-specific imports adds slight complexity. The sentinel class is concise but could benefit from type annotations on methods. Overall, the code is maintainable and understandable, but the import block and subtle compatibility-related details slightly reduce the readability score.
Run 3
The code demonstrates excellent readability. The structure is logically organized with clear section separation: imports are grouped (standard library, third-party, relative), class definition follows, and documentation is placed appropriately. Nesting is minimal—the code is flat with only a class containing a few methods. Clarity of intent is strong: the _Nothing sentinel's purpose is well-documented with clear docstrings explaining the problem it solves and version changes. Code length is concise—no unnecessary lines or verbosity. Action granularity is appropriate: methods like __repr__ and __bool__ are single-purpose, one-line implementations. Reading flow is natural: sentinel pattern, then enum auto-initialization, then simple dunder methods. Minor deductions: the docstring mentions typing.Literal usage but doesn't show an example, and the large import block could potentially be condensed. Overall, this is exemplary readable Python code that follows idiomatic patterns and maintains clarity throughout.
Run 1
Code Structure: Imports are grouped sensibly, followed by a small, focused enum class. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive docstring clearly explains the sentinel's purpose, and the short methods make its representation and boolean behavior explicit. Code length: The implementation is concise; the compatibility notes add useful context without excessive detail. Action granularity: Each statement performs a single action, with no compressed multi-action lines. Reading flow: The progression from imports to documentation, enum member, and behavior methods is natural. Minor drawbacks are the large import block relative to the shown implementation and limited blank-line separation between import groups and the class.
Run 2
Code Structure: Imports precede a clearly defined sentinel enum, providing logical organization, though the many imports are unused in this excerpt. Nesting: Minimal nesting makes the class easy to scan. Clarity of intent: The descriptive docstring explains why the sentinel exists, and the representation and boolean methods have obvious purposes. Code length: The implementation is concise; documentation and imports dominate the excerpt but do not obscure its behavior. Action granularity: Each statement occupies its own line, with no compressed or combined actions. Reading flow: The sequence from imports to documentation, enum member, and special methods is natural. Additional blank lines between import groups and before the top-level class would improve visual separation.
Run 3
Code Structure: Imports are grouped by source, followed by a focused sentinel class; clearer spacing between groups would improve organization. Nesting: Minimal, with only a class and short methods. Clarity of intent: The descriptive class name, docstring, and explicit enum member clearly explain the sentinel's purpose and behavior. Code length: The implementation is concise, although the extensive imports appear unnecessary for this excerpt. Action granularity: Each statement performs one action, with no compressed or compound statements. Reading flow: The progression from imports to documentation, definition, and behavior is natural; the long import section slightly delays reaching the small implementation.