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. It has a clear, logical structure with grouped imports (standard library, third-party, local) and well-organized custom imports. Nesting is minimal, with only class and method definitions at top level. The intent is explicit through the sentinel enum pattern, comprehensive docstring, and type annotations. Code length is appropriate—concise yet informative. Each action is on its own line, and the reading flow is natural, moving from imports to class definition to methods. The use of future annotations, enum, and clear naming conventions enhances maintainability. Minor deductions only for potential import complexity, but overall this is exemplary readable Python code.
Run 3
The code demonstrates strong readability through clear module organization with grouped imports (standard library, third-party, relative). The _Nothing enum is well-documented with detailed docstrings explaining version changes and usage context. Naming is descriptive and follows Python conventions. The structure is flat with no unnecessary nesting. Each action is cleanly separated - enum definition, method overrides, and imports are logically distinct. Type hints and future imports are properly used. The enum sentinel pattern is clearly explained through comments and structure. Minor deductions: the import block is somewhat extensive (though necessary for the library), and the docstring line about version changes could potentially be simplified, but overall the code is highly readable with clear intent and excellent documentation practices.
Run 1
Code Structure: Imports are grouped before a small, self-contained enum class. Nesting: Minimal, with only straightforward methods inside the class. Clarity of intent: The descriptive docstring clearly explains the sentinel's purpose, and the methods explicitly define its representation and boolean behavior. Code length: The implementation is concise; the import list is extensive for this excerpt but may support the larger module. Action granularity: Each statement performs one action, with no compressed or compound lines. Reading flow: The sequence from imports to documentation, enum member, and behavior is natural. Minor spacing improvements between import groups and before the class would further improve readability.
Run 2
Code Structure: Imports precede a clearly defined sentinel enum, giving the snippet a logical organization, although many imports are unused within the excerpt. Nesting: Minimal nesting keeps the class and its methods easy to follow. Clarity of intent: The descriptive docstring explains why the sentinel exists, and the short methods clearly define its representation and Boolean behavior. Code length: The implementation is concise; imports and version-history documentation account for most of the length. Action granularity: Each statement occupies its own line, with no compressed multi-action expressions. Reading flow: The sequence from imports to documentation, enum member, and behavior is natural. Additional blank lines between import groups and before the top-level class would improve visual separation.
Run 3
Code Structure: Imports and the sentinel enum are logically organized, though the numerous imports are unused in this excerpt. Nesting: Minimal nesting makes the class easy to follow. Clarity of intent: The class docstring clearly explains why the sentinel exists, and the representation and Boolean methods communicate its behavior directly. Code length: The implementation is concise; the compatibility notes and extensive imports add some reading overhead. Action granularity: Each statement performs a single action. Reading flow: The progression from imports to documentation, enum member, and methods is natural, although additional spacing between import groups and before the class would improve visual separation.