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, a logical class definition, and clear intent. The _Nothing enum is concise and uses standard Python patterns (enum, dunder methods) appropriately. Nesting is minimal, and action granularity is one action per line. The reading flow is natural: imports first, then class definition with a clear docstring explaining purpose and version changes, then methods in a logical order. Minor deductions include the slightly long import block and use of some relatively advanced features (__future__ annotations, cached_property) that might slightly impact beginner readability, but overall this is a clean, professional code snippet.
Run 3
The code is well-structured, with clear separation of imports from local modules, standard library, and third-party packages. The class definition is concise and the use of an enum sentinel with clear docstring demonstrates good clarity of intent. Nesting is minimal; the `_Nothing` class is flat and each method performs one action. The reading flow is natural, with logical grouping of imports and the class definition following. The code is slightly verbose with detailed docstrings and future annotations, but this enhances clarity. Overall, highly readable with only minor length considerations.
Run 1
Code Structure: Imports are grouped logically, followed by a focused sentinel class. Nesting: Minimal nesting makes the class easy to scan. Clarity of intent: The descriptive class docstring clearly explains the sentinel, its purpose, and compatibility history; the methods have straightforward behavior. Code length: The implementation is concise, although the extensive import list is disproportionate to this excerpt. Action granularity: Each statement performs a single action, with no compressed or compound lines. Reading flow: The progression from dependencies to documentation, enum member, and special methods is natural. A little more spacing between import groups and the class would improve visual separation.
Run 2
Code Structure: Imports are grouped coherently, followed by a small, self-contained sentinel class. Nesting: Minimal, with only class methods and no nested control flow. Clarity of intent: The descriptive docstring explains the sentinel's purpose, and the methods clearly define its representation and boolean behavior. Code length: The implementation is concise; the numerous imports are unused in this excerpt and add some visual overhead. Action granularity: Each statement performs a single action. Reading flow: The progression from imports to documentation, enum member, and behavior is natural, though additional blank lines between import groups and before the class would improve visual separation.
Run 3
Code Structure: Imports are grouped sensibly, followed by a single, cohesive sentinel class. Nesting: Minimal nesting makes the class and its methods easy to scan. Clarity of intent: The descriptive class name and docstring clearly explain why the sentinel exists; __repr__ and __bool__ have obvious behavior. Code length: The implementation is concise, although the extensive imports are unrelated to the displayed class and add visual overhead. Action granularity: Each statement performs one action, with simple one-line method bodies. Reading flow: The sequence from imports to documentation, enum member, and behavior is natural. An additional blank line before the top-level class would improve conventional Python formatting.