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. It uses clear imports, a concise class definition with attrs, and a straightforward logical flow in the __call__ method. Nesting is minimal—only one loop with a try/except/else block. Intent is clear: validate that at least one validator passes. The code is concise and each line performs a single action. The reading flow is natural, moving from imports to class definition and method logic. Minor deductions could be made for the broad exception handling (BLE001) and slightly dense error message construction, but overall it is highly readable and maintainable.
Run 3
The code is generally readable with clear structure and purpose. It defines a validator class using attrs, with a straightforward __call__ method implementing OR logic. The nesting is minimal (one for loop, one try/except), and each action is on its own line. However, readability is slightly reduced by the broad exception handling with multiple noqa suppressions, which obscures the intent of catching all exceptions. The import of `operator` is unused, and the from-imports for contextmanager, Pattern, get_run_validators, set_run_validators, _AndValidator, and_, and default_if_none are not used in this snippet, adding visual noise. The f-string in the error message is clear but verbose. Overall the code is concise and logically organized, but the unused imports and permissive exception handling prevent a higher score.
Run 1
Code Structure: The class cleanly separates validation logic from representation, though several unused imports add clutter. Nesting: A loop containing try/except/else introduces moderate but manageable nesting. Clarity of intent: The class name, validators attribute, and error message clearly express OR-style validation; the short variable name v and broad exception handling slightly obscure details. Code length: The implementation is concise, with little unnecessary logic beyond the imports. Action granularity: Each line generally performs one action. Reading flow: Validation attempts, successful early return, and final failure follow a natural sequence; the noqa annotation adds minor visual noise.
Run 2
Code Structure: A small, logically organized class separates validation and representation. Nesting: The loop and try/except/else introduce moderate but manageable nesting. Clarity of intent: The class name, error message, and early return clearly express that any validator may succeed; the abbreviated name 'v' and broad exception handling slightly obscure details. Code length: The implementation is concise, although numerous unused imports distract within this snippet. Action granularity: Each line performs one clear action, with no compressed statements. Reading flow: Validation proceeds naturally from trying alternatives to reporting failure, followed by a straightforward representation method. The suppression comment adds some visual noise but does not significantly hinder readability.
Run 3
Code Structure: The class logically groups validator state, validation behavior, 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-style validation; the abbreviated name v and broad exception handling slightly obscure details. Code length: The implementation is concise without unnecessary repetition. Action granularity: Each line generally performs one action, with no compressed multi-statement expressions. Reading flow: Validation proceeds naturally from trying alternatives to reporting failure, with helpful whitespace separating the failure path.