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,
)
@attrs(slots=True, unsafe_hash=True)
class _AndValidator:
_validators = attrib()
def __call__(self, inst, attr, value):
for v in self._validators:
v(inst, attr, value)
Run 1
The code is generally readable and well-structured. Imports are organized logically, with standard library and third-party imports grouped. The class uses the attrs decorator for concise attribute definition. The _AndValidator class has a clear purpose as a composite validator. However, there's an unnecessary blank line after the class definition, and one could argue the validator loop could be more explicit about exception handling. The naming is conventional and the type hints suggest modern Python practices. The code is flat and each method has a single responsibility, but the partial nature of the snippet makes it harder to assess overall structure. Overall, it demonstrates solid readability with minor cosmetic issues.
Run 2
The code is partially understandable but has a major syntax error: it uses `@attrs`, `attrib()`, and type annotations as if `attr` decorators were imported, but they are not. This makes the intent unclear and the code unusable. The imports are organized alphabetically and grouped logically (stdlib vs local), which is good. However, there are unnecessary imports for such a small snippet, adding noise. The class `_AndValidator` shows clear intent—validating multiple validators sequentially—but the decorators are ambiguous without proper imports. Nesting is flat, and action granularity is acceptable in the `__call__` method. Reading flow is disrupted by the missing import and the blank line after the class declaration. Overall, the structure and formatting are decent, but the missing import made the code non-functional and confusing, significantly lowering readability.
Run 3
The code shows a reasonable logical structure with imports grouped by standard library, third-party, and local modules. It has flat nesting and is relatively concise. The class _AndValidator has a clear, single-purpose intent. However, readability is undermined by several factors: the decorator 'attrs' and function 'attrib' are not imported in the visible snippet, making the code non-self-contained and ambiguous to readers unfamiliar with the attrs library. The class lacks a docstring explaining its role, and the blank line between the class definition and the first attribute is unnecessary. The 'unsafe_hash=True' argument adds cognitive overhead without context. Line length is generally good, but the import section is long and includes many unused-looking imports. Action granularity is acceptable, with one action per line. The reading flow is natural but could be improved with clearer class documentation and explicit import context.
Run 1
Code Structure: The validator class is logically organized, but the extensive import block overwhelms the small implementation and includes many unused imports. Nesting: Only a single loop is nested inside a method, making control flow easy to follow. Clarity of intent: _AndValidator and _validators convey that all validators are applied, although abbreviated parameters and the unexplained attrs/attrib references reduce standalone clarity. Code length: The implementation is concise, but imports and extra blank lines add unnecessary bulk to this snippet. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: The class reads naturally from its stored validators to their invocation, though the disproportionate imports delay reaching the relevant logic.
Run 2
Code Structure: The validator class is logically organized, but the large import block is disproportionate to the small snippet and includes many unused imports. Nesting: Minimal nesting makes execution easy to follow. Clarity of intent: The class name and loop clearly indicate combining validators, although abbreviated names such as v, inst, and attr reduce explicitness, and attrs and attrib are not imported in the shown code. Code length: The implementation is concise, but excess imports and blank lines add clutter. Action granularity: Each line performs a single clear action. Reading flow: The class reads naturally from stored validators to their invocation, though the import-heavy opening distracts from its purpose.
Run 3
Code Structure: The validator class is logically organized, but the large import block is disproportionate to the small implementation and contains many unused imports in this snippet. Nesting: Minimal nesting—a single loop inside a method—makes execution easy to follow. Clarity of intent: The class name and loop clearly suggest combining validators, although abbreviated names such as v, inst, and attr are less descriptive, and attrs/attrib are not defined or imported in the shown code. Code length: The implementation is concise, but excess imports and blank lines add visual clutter. Action granularity: Each statement performs one clear action. Reading flow: The class flows naturally from stored validators to invocation, though the lengthy import preamble delays reaching the relevant logic.