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 and readable. It uses clear naming conventions, proper imports, and a meaningful class name `_Nothing` with a clear docstring explaining its purpose. The nesting is minimal, and actions are separated logically (imports, class definition, methods). The class methods are concise and each performs a single action. The use of `enum.Enum` and `enum.auto()` is idiomatic. Only minor issues: import block is somewhat long, and `_Nothing` could be private but that is intentional. Overall, highly readable with clear intent.
Run 3
The code is highly readable with clear structure: imports are organized in logical groups (stdlib, third-party, local), and the module-level class _Nothing is well-defined. The class has a clear purpose with a concise docstring explaining its role and version changes. Nesting is minimal and flat. The class uses Enum appropriately, and methods are short, single-action, and descriptive. Naming conventions follow Python standards, and type hints/annotations are present. The use of __future__ import and explicit imports from local modules demonstrates good practices. Minor deductions: a few imports appear unused (e.g., Callable, Mapping, TypeVar), and the versionchange directives slightly interrupt reading flow, but overall the code is exemplary.
Run 1
Code Structure: Imports are grouped logically, followed by a small, focused sentinel class. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive docstring clearly explains the sentinel’s purpose, and the methods directly express its representation and boolean behavior. Code length: The class is concise; the extensive imports are unused in this excerpt and add some visual overhead. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: The progression from imports to documentation, enum member, and methods is natural. An additional blank line before the top-level class would improve conventional formatting.
Run 2
Code Structure: Imports are grouped by source, followed by a focused sentinel class. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive docstring clearly explains the sentinel's purpose, and the methods explicitly define its representation and truthiness. Code length: The implementation is concise; version notes add useful context, though the extensive imports are not used in this excerpt. Action granularity: Each statement performs a single action. Reading flow: The progression from imports to documentation, enum value, and behavior is natural. A second blank line before the top-level class would improve formatting consistency.
Run 3
Code Structure: Imports are grouped logically, followed by a focused sentinel class. Nesting: The code is flat, with only simple methods inside the class. Clarity of intent: Descriptive naming and a detailed docstring clearly explain the sentinel's purpose and behavior. Code length: The implementation is concise; the import list is extensive relative to this excerpt, and version-history notes add some reading overhead. Action granularity: Each statement performs one action, with no compressed or compound statements. Reading flow: The progression from dependencies to declaration and behavior is natural, though additional spacing between import groups and before the class would improve visual separation.