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 with clear class and method definitions. The use of the attrs decorator reduces boilerplate and clarifies intent. Nesting is minimal, limited to a single for-loop with try/except/else, which is acceptable. However, readability is slightly hindered by the broad exception handling with multiple noqa comments, which may obscure intent, and by the generic variable name 'v' for validators. The f-strings and repr methods are concise, but the exception handling flow, with its continue/else/return pattern, could be clearer with a comment or refactoring. Overall, the code is readable but not outstanding.
Run 3
The code is a well-structured, readable Python class definition. It has a clear purpose: implementing an 'or' validator that passes if any sub-validator succeeds, otherwise raising a ValueError. The class is concise with a single-level loop and try/except/else blocks, maintaining flat nesting. Each action (loop, try, continue, return, raise) is clearly separated with good line granularity. Imports are grouped logically. Naming is descriptive (_OrValidator, validators, inst, attr, value) and the error message is informative. The only minor issues are the terse variable names 'inst' and 'v' and the slightly dense contextmanager/Pattern imports (likely used elsewhere), but these are conventional in attrs validators and don't significantly harm readability.
Run 1
Code Structure: The class cleanly separates validation behavior from representation, though several unused imports add clutter. Nesting: The loop and try/except/else introduce moderate nesting but remain easy to follow. Clarity of intent: The class name, validators attribute, and error message clearly communicate that any validator may succeed; the abbreviated name v and broad exception handling slightly obscure details. Code length: The implementation is concise, with no unnecessary logic, although the import list is excessive for this snippet. Action granularity: Each line generally performs one action, and error-message construction is separated from raising the exception. Reading flow: Validation proceeds naturally from trying each validator to returning on success or raising after all fail. The suppression comment is visually noisy, and a blank line before the decorated class would improve formatting.
Run 2
Code Structure: The validator is logically organized into state, validation behavior, and representation. Nesting: The loop and try/except introduce moderate but manageable nesting. Clarity of intent: The class name, error message, and early return clearly express OR-style validation; however, the short name 'v' and broad exception handling obscure some detail. Code length: The implementation is concise, though several imports are unused in the provided snippet. Action granularity: Each line performs a single clear action. Reading flow: Validation attempts, continuation on failure, return on success, and final failure follow a natural sequence. Framework decorators and lint-suppression annotations add minor reading overhead.
Run 3
Code Structure: The class cleanly groups validator storage, invocation, and representation, although several imports are unused in this snippet. Nesting: The loop and try/except/else introduce moderate nesting, but continue and return keep control flow manageable. Clarity of intent: The class name, error message, and representation clearly communicate OR validation; the short names v, inst, and attr are less descriptive, and catching every Exception can obscure which failures are expected. Code length: The implementation is concise with little redundancy, aside from unused imports. Action granularity: Each line generally performs one action. Reading flow: Execution naturally progresses from trying validators to returning on success or raising after all fail; the suppression comment adds minor visual noise.