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 highly readable with clear organization and flat structure. It uses logical imports, a well-documented sentinel enum, and follows Python best practices. The nesting is minimal, intent is clearly conveyed through naming and docstrings, and line length is appropriate with one action per line. The reading flow is natural, moving from imports to class definition. The only minor deductions are due to the large import block and slight verbosity in docstrings, but these do not significantly impact readability.
Run 3
The code is well-structured, with clear separation of imports, a single class definition, and a concise docstring. Imports are organized into standard library, third-party, and local modules, improving readability. The nesting is minimal, with only one class and one method each for __repr__ and __bool__. Intent is clear: _Nothing is a sentinel enum with explicit behavior. Code length is appropriate, avoiding unnecessary verbosity. Each action (e.g., enum.auto(), return statements, __bool__) occupies its own line, supporting action granularity. Reading flow is natural, moving from imports to class definition to methods. Minor deductions: absence of type annotations for return types on __repr__ and __bool__, and the docstring includes version notes that slightly interrupt flow. Overall, highly readable.
Run 1
Code Structure: Imports are grouped logically, followed by a focused sentinel class. Nesting: Minimal nesting makes the implementation easy to scan. Clarity of intent: The descriptive docstring explains why the sentinel exists, and the methods clearly define its representation and truthiness. Code length: The implementation is concise; the extensive imports appear unnecessary for this excerpt, though they may support the surrounding module. Action granularity: Each statement performs one clear action. Reading flow: The progression from imports to documentation, enum member, and behavioral methods is natural. Additional spacing between import groups and before the class would slightly improve readability.
Run 2
Code Structure: Imports precede a small, logically organized enum class, though several imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class docstring clearly explains the sentinel’s purpose, while the methods straightforwardly define its representation and boolean behavior. Code length: The implementation is concise; the extensive import block is disproportionate to the displayed functionality. Action granularity: Each statement performs one clear action. Reading flow: The progression from documentation to enum member to behavior is natural, although an additional blank line before the top-level class would improve visual separation.
Run 3
Code Structure: Imports are grouped by source, followed by a focused sentinel enum. Nesting: Minimal, with only class and method scopes. Clarity of intent: The descriptive docstring clearly explains the sentinel's purpose, and the methods explicitly define its representation and false boolean value. Code length: The implementation is concise; documentation adds useful context, although the many imports are unused in this excerpt. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: The progression from imports to documentation, enum member, and behavior is natural. An additional blank line before the top-level class would improve conventional Python formatting.