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 demonstrates strong readability through clear structure and organization. The imports are logically grouped (standard library, third-party, local modules) and each import serves an apparent purpose. The _Nothing class uses an Enum with proper documentation, including version notes that provide historical context. The sentinel pattern is well-implemented with clear docstring explaining the rationale for using an Enum over None. Naming conventions are descriptive and follow Python standards. The class methods are concise with single responsibilities. The nesting is minimal, with no deep indentation levels. Type hints from __future__ import show forward-looking compatibility. Minor deductions: some imported symbols like _lazy_is_generator and _AnnotationExtractor are not immediately obvious in purpose, and the import list is lengthy, requiring readers to scan through many names. The code could benefit from grouping related imports with brief comments. Overall, the code prioritizes clarity through documentation and logical organization, making it highly maintainable for both current and future developers.
Run 3
The code is highly readable. Imports are logically organized and grouped, with clear separation of standard library, third-party, and local modules. The module uses modern Python features like `from __future__ import annotations` and `enum.Enum` for the sentinel `_Nothing`. The `_Nothing` class is concise, with clear intent and proper documentation, including version notes. Indentation is flat, and each action is on its own line. Naming is descriptive and consistent with Python conventions. The code is not excessively long; it only includes what appears necessary for the snippet. Overall, the structure and flow make the code easy to understand and maintain.
Run 1
Code Structure: Imports are grouped logically, followed by a small, cohesive sentinel class. Nesting: Minimal nesting makes the code 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; compatibility notes add useful context, though 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 dependencies to documentation, enum member, and behavior is natural. A second blank line before the top-level class would slightly improve visual separation.
Run 2
Code Structure: Imports precede a small, logically organized 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 express its representation and truthiness directly. Code length: The implementation is concise; the extensive imports add some reading overhead relative to the small excerpt. Action granularity: Each statement performs a single action. Reading flow: The progression from dependencies to documentation, enum value, and behavior is natural, though stronger spacing between import groups and before the class would improve visual separation.
Run 3
Code Structure: Imports are grouped by source, followed by a self-contained sentinel class, though many imports are unused in this excerpt. Nesting: Minimal, with only class and method scopes. Clarity of intent: The descriptive docstring clearly explains why the sentinel exists, while __repr__ and __bool__ make its behavior explicit. Code length: The implementation is concise; the extensive import list and version-history documentation add some overhead relative to the small class. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: The code progresses naturally from dependencies to definition and behavior, although an additional blank line before the top-level class would improve visual separation.