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:
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 generally well-structured and readable. Imports are organized logically. The class uses the attrs decorator to reduce boilerplate, which is clear and concise. The __call__ method has a flat structure with a single loop and clear try/except/else logic. Variable names are descriptive, and the error message is informative. However, the broad except Exception is slightly ambiguous and could be more specific to validation errors. The blank line after 'except Exception:' contains trailing whitespace, a minor formatting issue. Overall, the code is easy to follow with a natural reading flow, though it could benefit from a specific exception type and minor cleanup.
Run 2
The code is generally readable with clear imports, logical structure, and concise implementation. The _OrValidator class is well-organized, using the attrs decorator efficiently. The __call__ method has a flat structure with a clear try-except-else pattern, though the empty except with just 'continue' could be more explicit. The intent is clear: attempt multiple validators and succeed if one passes. The error message is informative. Minor improvements could include adding a comment explaining why exceptions are suppressed and using more descriptive variable names than 'v'. The code length is appropriate and each line performs a single action. Overall, this is maintainable code with good readability.
Run 3
The code is generally readable with clear imports and a single, well-defined class. Structure is logical, and the class has one responsibility. Nesting is minimal (one loop, one try/except/else). Intent is mostly clear, though the `unsafe_hash=True` parameter and the `attrib()` declarations assume attrs library familiarity. The `__call__` method is concise but could be clearer by extracting the validation loop or using a comment. Action granularity is good—one action per line. Reading flow is natural. Minor issues: the `except Exception:` blank line has trailing whitespace, and variable names `v`, `inst`, `attr` are terse but conventional for validators. Overall, code is compact and readable for those familiar with attrs.
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 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 catch slightly obscure what failures are expected. Code length: The implementation is concise, with little unnecessary code beyond the imports. Action granularity: Each line performs a single clear action. Reading flow: Validation proceeds naturally from trying each validator to reporting total failure, with helpful whitespace separating the final error path.
Run 2
Code Structure: The class is logically organized, separating validation behavior from representation, although 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 communicate that any validator may succeed; the abbreviated name v and broad Exception catch make individual failures less explicit. Code length: The implementation is concise without unnecessary duplication. Action granularity: Each statement performs a single clear action. Reading flow: Execution follows a natural sequence—try validators, return on success, then raise if all fail. Import clutter and the try/except/else structure slightly reduce readability.
Run 3
Code Structure: The class is logically organized, with a validation method and a separate representation method; several imports are unused in this snippet. Nesting: A loop containing try/except/else introduces moderate but manageable nesting. Clarity of intent: The class name, success return, and final error clearly communicate OR-style validation, though the abbreviated names v, inst, and attr slightly reduce clarity. Catching every Exception obscures which failures are intended to count as validation failures. Code length: The implementation is concise, with little unnecessary code beyond the unused imports. Action granularity: Each line performs a single, understandable action. Reading flow: The progression from trying validators to returning on success or raising after all fail is natural, supported by useful whitespace.