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, flag, item, index):
for age in self._validators:
age(flag, item, index)
Run 1
The code is a partial snippet showing imports and a small class definition. Organization is logical with imports grouped, and the class uses decorators and docstrings. However, clarity suffers due to the incomplete and ambiguous context: the decorator `@attrs`, `attrib()`, and parameters `flag, item, index` are unexplained, making intent unclear. Variable naming is poor (`age` instead of `validator`), which obscures purpose. Nesting is flat and action granularity is reasonable. Code length is concise, but the lack of surrounding context and unclear naming reduce readability. Overall, structure is sound but semantic clarity is lacking.
Run 2
The code is difficult to evaluate fully because it appears to be an incomplete snippet, but several issues are immediately apparent. The structure is fragmented: it imports many modules and symbols but only shows a small class definition, suggesting the full file may be large and disorganized. Nesting is flat, which is good, but clarity of intent is severely undermined by poor naming — 'age' is used as a loop variable for validators, and 'flag' and 'item' are vague. The class name '_AndValidator' is reasonably clear, but the docstring is minimal and the __call__ method's purpose is ambiguous without context. Code length is acceptable for the visible portion, but the many unused imports (e.g., abc, enum, linecache, weakref, types) inflate the file size without evident purpose. Action granularity is mostly one action per line, but the loop variable 'age' obscures readability. Reading flow is disrupted by the odd variable names and incomplete-looking class. Overall, the snippet lacks the clarity and purposeful organization expected in readable code, though the flat nesting and concise method body prevent a lower score.
Run 3
The code shows good structure with clear imports and a well-defined class, but has significant readability issues. The class has too many responsibilities - it appears to be both a validator and a handler, which creates ambiguity. The method has multiple actions in a single line and the naming is inconsistent ('age' variable name is unclear). The nesting is acceptable but the type hints and decorators add complexity without clear benefit. The code length is reasonable for the functionality, but the intent isn't immediately clear. The reading flow is disrupted by the mixing of concerns and unclear variable names. Better separation of concerns and more descriptive variable names would improve readability.
Run 1
1. Code Structure: Imports and a small validator class are logically organized, but numerous unused imports obscure the relevant dependencies; attrs and attrib are not defined or imported in the snippet. 2. Nesting: Minimal nesting makes the call method easy to follow. 3. Clarity of intent: The class name and docstring clearly describe validator composition, but flag, item, index, and especially age are unclear parameter and variable names. 4. Code length: The implementation is concise, while the extensive import section is disproportionate to the shown functionality. 5. Action granularity: Each statement performs one action, with no compressed multi-operation lines. 6. Reading flow: The class reads naturally from description to stored validators to invocation, but irrelevant imports and ambiguous naming interrupt comprehension.
Run 2
1. Code Structure: Imports precede a small, logically organized validator class, but many imports appear unused, and attrs/attrib are not defined or imported in the snippet. 2. Nesting: Minimal nesting makes the execution path easy to follow. 3. Clarity of intent: The class name and docstring clearly describe validator composition, but names such as flag, item, index, and especially age obscure the arguments and callable roles. 4. Code length: The class is concise, while the lengthy import section adds considerable overhead relative to the shown functionality. 5. Action granularity: Each line performs a single action, with no compressed statements. 6. Reading flow: The class reads naturally from declaration to iteration and invocation, though import clutter and missing blank-line separation between import groups reduce overall readability.
Run 3
Code Structure: Imports and the validator class are logically separated, but many imports are unused in this snippet, and attrs and attrib are not visibly imported. Nesting: Minimal nesting makes execution easy to follow. Clarity of intent: The class name and docstring clearly describe validator composition, but names such as age, flag, item, and index obscure the roles of the validator and its arguments. Code length: The implementation is concise, although the extensive import block overwhelms the small class. Action granularity: Each line performs one clear action. Reading flow: The class reads naturally from declaration to iteration and invocation, but unrelated imports and misleading variable names interrupt comprehension.