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:
"""
Compose many validators to a single one.
"""
_validators = attrib()
def __call__(self, a, b, c):
for d in self._validators:
d(a, b, c)
Run 1
The code structure is clean with a clear separation of imports and class definition, and the import grouping is logical. Nesting is minimal—the only indentation is a simple for-loop within the `__call__` method. The class purpose is documented with a concise docstring, making intent clear. The code is concise overall, though `__call__` uses non-descriptive names (`a`, `b`, `c`, `d`) that slightly reduce clarity. Action granularity is good—one logical operation per line. Reading flow is mostly natural, but the use of short variable names in the validator method and the lack of type hints on `a`, `b`, `c` interrupt comprehension. The import of many typing and compatibility symbols may exceed the needs of this snippet but does not affect readability significantly.
Run 2
The code demonstrates organized imports and a simple validator class, but suffers from poor naming and unclear intent. The loop variable names 'a', 'b', 'c', and 'd' are meaningless, obscuring the validator's purpose. The class structure is flat and concise, but the methods lack docstrings explaining the call signature. While the code avoids deep nesting, the action granularity is mixed—'__call__' compresses iteration into a loop without clarifying error propagation. The reading flow follows a logical top-down order, yet the abstract nature and non-descriptive arguments reduce clarity. Overall, the structure is clean but the clarity of intent and naming significantly hinder readability.
Run 3
The code imports are organized and the use of `__future__` annotations shows modern Python practices. The decorator and class structure are logically arranged with minimal nesting and single-purpose actions. The class `_AndValidator` is concise, with a clear `__call__` method that delegates to each validator. However, parameter names `a`, `b`, `c`, and loop variable `d` are ambiguous, reducing clarity of intent. The `@attrs(...)` decorator and `attrib()` usage rely on external library knowledge, which may confuse readers unfamiliar with attrs. While the code is short and flat, the lack of descriptive naming and internal documentation hinders readability. A minor improvement would be to rename parameters and loop variable to reflect their roles (e.g., `instance`, `attribute`, `value`, `validator`).
Run 1
Code Structure: Imports are grouped sensibly, and the validator class is logically organized, though most imports are unused in this snippet and attrs/attrib are not visibly defined or imported. Nesting: Very shallow, with only a loop inside a method. Clarity of intent: The class name, docstring, and _validators field clearly indicate validator composition, but parameter names a, b, c and loop variable d obscure their roles. Code length: The implementation is concise, although the extensive import section overwhelms the small class. Action granularity: Each statement performs one clear action. Reading flow: The class reads naturally from declaration to stored validators to invocation, but the disproportionate imports and unexplained decorator dependencies interrupt understanding.
Run 2
Code Structure: The validator class is logically organized, but the large import block is mostly unrelated to the shown implementation. Nesting: A single loop inside a method keeps nesting shallow. Clarity of intent: The class name, docstring, and _validators attribute clearly indicate validator composition, but a, b, c, and d obscure argument and validator roles. The origins of attrs and attrib are not shown, reducing self-contained clarity. Code length: The implementation is concise, although imports dominate this short snippet. Action granularity: Each statement performs one action, with no compressed multi-operation lines. Reading flow: The class reads naturally from description to stored validators to invocation, but excessive imports and vague parameter names interrupt comprehension.
Run 3
Code Structure: Imports are grouped before a small, logically organized validator class, though many imports appear unrelated to this excerpt and attrs/attrib are not defined here. Nesting: Minimal nesting makes the loop easy to follow. Clarity of intent: The class name, docstring, and _validators field communicate validator composition, but parameter names a, b, c and loop variable d obscure their roles. Code length: The implementation is concise, while the extensive import block adds distraction relative to the shown functionality. Action granularity: Each line performs a single clear action. Reading flow: The class reads naturally from documentation to state to behavior, but import clutter and unexplained decorator dependencies interrupt comprehension.