Source code
import operator
import re
from contextlib import contextmanager
from re import Pattern
from ._config import get_run_validators, set_run_validators
from ._make import _AndValidator, and_, attrib, attrs
from .converters import default_if_none
from .exceptions import NotCallableError
@attrs(repr=False, slots=True, unsafe_hash=True)
class _OrValidator:
validators = attrib()
def __call__(self, inst, attr, value):
for v in self.validators:
try:
v(inst, attr, value)
except Exception: # noqa: BLE001, PERF203, S112
continue
else:
return
raise ValueError((f"None of {self.validators!r} satisfied for value {value!r}"))
def __repr__(self):
return f"<or validator wrapping {self.validators!r}>"
Run 1
The code demonstrates strong readability through clear structure and purposeful organization. The _OrValidator class is logically constructed with a straightforward __call__ method that implements the validator pattern effectively. The nesting is minimal with only one level of depth in the try-except-else block, maintaining flatness. Intent is clear: iterate through validators and raise an error if none succeed. Action granularity is appropriate, with each logical operation on its own line. The try-except-else pattern is idiomatic Python for this use case. The unused blank line before the final raise statement and minor formatting inconsistency in whitespace slightly impact flow. Import organization is clean with standard library imports preceding relative imports. The code length is concise for its purpose, avoiding unnecessary verbosity while maintaining clarity. The exception handling comment is informative, explaining why broad exception catching is intentional in this context. Type hints could improve clarity further but the absence doesn't significantly reduce readability.
Run 2
The code is fairly readable and follows common patterns for a validator class using attrs. The structure is logical: imports are grouped, the class is small, and the `__call__` method has a clear loop-and-try pattern. Nesting is minimal, with only one level inside the for loop. However, readability suffers in a few places: the bare `raise ValueError(...)` is preceded by two blank lines, creating awkward vertical whitespace; the broad exception handling is flagged with multiple `noqa` comments that hint at hidden complexity; and the f-string in the error is long and dense. Action granularity is generally good, but the loop body crams several logical steps (validation, exception handling, flow control) into short lines, which slightly obscures intent. Overall, the code is understandable but could be tightened with better spacing and a more explicit error construction. The class is concise, but minor formatting and exception-handling choices prevent it from being highly readable.
Run 3
The code is generally readable, with clear structure and intent. It defines a single class with a clear purpose, uses type hints and modern attrs features. The __call__ method uses a straightforward for-else pattern, but the exception handling (catching broad Exception and intentionally swallowing it) slightly obscures intent. The blank line before the final raise is unnecessary and breaks flow. The nested try-except-else inside a for loop adds moderate nesting but remains understandable. Naming is consistent, and line length is reasonable. Overall, the code is maintainable but could improve error specificity and minor formatting.
Run 1
Code Structure: The class is logically organized into state, validation behavior, and representation, though several unused imports add clutter. Nesting: The loop and try/except/else introduce moderate, manageable nesting. Clarity of intent: The class name, validators attribute, and error message clearly convey that any successful validator is sufficient; the abbreviated variable v and broad exception handling slightly obscure details. Code length: The implementation is concise, but redundant parentheses around the error message and excess blank lines are unnecessary. Action granularity: Each line generally performs one clear action. Reading flow: Validation proceeds naturally from trying alternatives to returning on success or raising on total failure, with only minor formatting distractions.
Run 2
Code Structure: The validator class is logically organized, with separate validation and representation methods, though several imports are unused in this snippet. Nesting: The loop and try/except/else introduce moderate, manageable nesting. Clarity of intent: The class name, validators attribute, and error message clearly convey that any successful validator is sufficient; however, the abbreviated name v and broad exception handling obscure which failures are intentionally ignored. Code length: The implementation is concise, but redundant parentheses around the error message and extra blank lines add minor clutter. Action granularity: Each line generally performs one action. Reading flow: Execution proceeds naturally through attempts, early success, and final failure, although lint-suppression comments slightly interrupt readability.
Run 3
Code Structure: The small validator class logically separates validation behavior from its representation, though several imports appear unused in this snippet. Nesting: The loop and try/except/else introduce moderate nesting, but the early return keeps control flow manageable. Clarity of intent: The class name, validators attribute, and error message clearly communicate that any successful validator is sufficient; the abbreviated variable v and broad exception handling slightly reduce clarity. Code length: The implementation is concise, with minor clutter from unused imports, extra blank lines, and redundant parentheses around the error message. Action granularity: Each line generally performs one clear action. Reading flow: Execution naturally progresses from trying validators to returning on success or raising on total failure, although the noqa directives add visual noise.