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 well-structured with clear imports grouped logically (standard library, then local modules). The _Nothing class has a focused, single responsibility with clear intent via its docstring and sentinel pattern. Nesting is minimal and flat, with no deeply nested logic. Each action is on its own line, improving readability. The use of enum.auto() and explicit dunder methods is concise and idiomatic. Minor deductions: some import complexity (conditional/version-specific names) slightly obscures intent without context, and the module lacks a top-level docstring explaining overall purpose. Overall, the code is highly readable, maintainable, and follows Python best practices.
Run 3
The code is well-structured with clear logical organization: imports are grouped by standard library, third-party, and local modules. It uses modern Python features (e.g., `__future__` annotations, `enum.auto()`) appropriately. The `_Nothing` class has a clear purpose as a sentinel, documented via a concise docstring. Nesting is minimal. Action granularity follows one statement per line. The only minor deductions are for the somewhat dense import block and the use of multiple version-specific conditional imports, which slightly reduces immediate readability for newcomers.
Run 1
Code Structure: Imports are grouped by source, followed by a single, focused enum class. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name and docstring clearly explain the sentinel's purpose, while the short methods make its representation and boolean behavior explicit. Code length: The implementation is concise; the imports and version-history notes add some overhead relative to this small excerpt. Action granularity: Each statement performs one action. Reading flow: The progression from imports to documentation, enum member, and behavior is natural. Minor spacing improvements between import groups and before the class would improve visual separation.
Run 2
Code Structure: Imports are grouped logically, followed by a focused sentinel class. Nesting: Minimal; methods contain only simple return statements. Clarity of intent: The descriptive docstring explains the sentinel's purpose and behavior, and the method implementations are straightforward. Code length: The class is concise, although the extensive imports are unused in this excerpt and add visual overhead. Action granularity: Each statement performs one clear action. 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 separation.
Run 3
Code Structure: Imports are grouped by source, followed by a focused sentinel class, though more spacing between groups would help. Nesting: Minimal, with only simple methods inside the class. Clarity of intent: The descriptive class docstring clearly explains the sentinel and its behavior; the method names follow standard Python conventions. Code length: The implementation is concise, although the numerous imports are unused in this excerpt and distract from its purpose. Action granularity: Each statement performs a single action. Reading flow: The class reads naturally from documentation to enum member to representation and boolean behavior, with minor visual crowding around the imports.