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 begins with well-organized imports, including future annotations and standard library modules, followed by third-party and local imports. The `_Nothing` class uses an Enum with an auto-generated value, a clear docstring detailing its purpose and version changes, and simple, focused methods. Each method has a single responsibility, and the code flow is logical and easy to follow. Slight minor deductions could apply due to the length of the import block and the use of a metaclass in a context not fully shown, but overall structure and clarity are excellent.
Run 3
The code is well-structured and readable. The imports are organized logically with clear grouping (stdlib, typing, local modules, specific attrs modules/exceptions). The use of `__future__ import annotations` at the top is a good practice. The `_Nothing` enum class is concise and its purpose is clearly documented via a docstring that includes version change notes. Names are descriptive and the code is flat with minimal nesting. There is no unnecessary verbosity; each method is a single logical action. The reading flow is natural: module imports, then a single sentinel class definition. This excerpt appears to be from a mature library and demonstrates consistent style. Minor readability improvements could come from breaking long import lines or using parentheses more consistently, but overall clarity is high.
Run 1
Code Structure: Imports are grouped sensibly, followed by a focused sentinel class. Nesting: Minimal nesting keeps the code easy to scan. Clarity of intent: The descriptive docstring clearly explains why the sentinel exists, and the methods have straightforward behavior. Code length: The implementation is concise; the imports are extensive relative to the shown functionality but may support the larger module. Action granularity: Each statement performs one clear action. Reading flow: The progression from imports to documentation, enum member, and special methods is natural. Minor spacing improvements between import groups and before the class would improve visual separation.
Run 2
Code Structure: Imports are grouped before a small, cohesive sentinel class, though many imports are unused in this excerpt. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name, explicit enum member, and informative docstring clearly explain the sentinel and its behavior. Code length: The implementation is concise; compatibility notes add documentation without complicating the logic. Action granularity: Each statement performs one clear action, with no compressed or compound operations. Reading flow: The class progresses naturally from documentation to the sentinel definition and its representation and truth-value methods. 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 focused sentinel class. Nesting: Minimal, with only short methods inside the class. Clarity of intent: The descriptive docstring explains the sentinel's purpose, and the enum member and methods make its representation and truthiness explicit. Code length: The implementation is concise; version-history documentation and the extensive imports add some overhead relative to the small excerpt. Action granularity: Each statement performs one clear action. Reading flow: The progression from dependencies to class documentation, member definition, and behavior is natural. An additional blank line before the top-level class would improve visual separation.