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
msg = f"None of {self.validators!r} satisfied for value {value!r}"
raise ValueError(msg)
def __repr__(self):
return f"<or validator wrapping {self.validators!r}>"
Run 1
The code is well-structured with clear imports and a single, focused class definition. It uses the attrs library effectively to reduce boilerplate. The _OrValidator class has a logical organization with distinct methods for call logic and representation. Nesting is minimal with only one loop and try/except block inside the __call__ method. Intent is clear: validate if any validator in a list passes. Code length is concise and appropriately sized for the functionality. Action granularity is generally good, though the try/except/else block could be slightly clearer. Reading flow is natural with a clear progression from class definition to method implementations. The main readability concerns are the single-letter variable 'v' and the dense try/except/else block in __call__, which could benefit from a helper method or more explicit control flow. Overall, this is readable code that follows common Python patterns.
Run 2
The code is well-structured and readable. The import section is organized, the class has a clear single responsibility, and the `__call__` method follows a flat, logical flow. Nesting is minimal (one loop with try/except/else), and the intent of validating against multiple validators with an 'or' relationship is evident. Action granularity is appropriate, with one main action per line. The code length is concise and avoids unnecessary verbosity. Reading flow is natural, following the validation logic from first validator to final fallback error. Minor deductions: the catch-all exception handler could be more specific but is justified for validator semantics; the `else` clause on the loop is slightly non-intuitive for less experienced readers.
Run 3
The code is well-structured with clear class and method organization. Nesting is minimal with only one level inside the __call__ method's loop. Intent is obvious: an OR validator that tries multiple validators and raises if none pass. Code is concise but maintains readability. Action granularity is appropriate - the try/except/else block handles exception flow cleanly on separate lines. Reading flow is natural and logical. Minor deductions: the exception handling with multiple noqa comments could be clearer about which specific exceptions are expected, and the class inherits from attrs with Python 3.7+ decorator syntax which assumes familiarity with the library, but overall this is highly readable code with good structure and clear intent.
Run 1
Code Structure: The small validator class is logically organized, with validation and representation separated; several unused imports add clutter. Nesting: The loop and try/except/else introduce moderate but manageable nesting. Clarity of intent: The class name, validators attribute, and error message clearly convey that any validator may succeed, though the abbreviated name v and broad exception handling obscure which failures are intentionally suppressed. Code length: The implementation is concise, but the imports are excessive for this snippet. Action granularity: Each line generally performs one action, making execution easy to follow. Reading flow: Validation proceeds naturally from trying each validator to returning on success or raising after all fail; decorator configuration and lint-suppression annotations add minor visual noise.
Run 2
Code Structure: The validator class is logically organized, separating validation behavior from representation, though several imports are unused in this snippet. Nesting: The loop and try/except/else introduce moderate but manageable nesting. Clarity of intent: The class name, validators attribute, and error message clearly express OR-style validation; the abbreviated names v, inst, and attr slightly reduce clarity. Catching every Exception obscures which failures are intended to indicate unsuccessful validation. Code length: The implementation is concise without unnecessary logic. Action granularity: Each line generally performs one action. Reading flow: Validation proceeds naturally through alternatives, returns on success, and raises after all fail. The decorator options and lint-suppression codes add some visual noise.
Run 3
Code Structure: The class is logically organized, separating validation behavior from representation. Nesting: The loop and try/except/else add moderate nesting, but the early return keeps control flow manageable. Clarity of intent: Names and the failure message clearly communicate that any wrapped validator may satisfy validation; however, the abbreviated name 'v' and broad exception handling obscure some details. Code length: The implementation is concise, though numerous imports are unused in the shown snippet and add clutter. Action granularity: Each line generally performs one action, with no compressed statements. Reading flow: Execution flows naturally from trying validators to returning on success or raising after all fail. The dense suppression comment and framework-specific decorator slightly interrupt readability.