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 generally readable with a clear structure and logical organization. Imports are properly grouped, and the class definition uses the attrs decorator concisely. The __call__ method follows a straightforward validation loop with clear intent. Nesting is minimal (single level in the try/except/else), and actions are mostly one per line. However, a few issues reduce readability: the except clause uses a broad Exception catch with multiple noqa suppressions, which obscures intent and suggests potential code smell. Additionally, the __repr__ method is placed immediately after __call__ without a blank line, slightly hurting visual separation. The f-strings are clear, but the error message could be more descriptive. Overall, the code is quite readable but could benefit from minor formatting improvements and more specific exception handling.
Run 2
The code is moderately readable. It has clear imports and a logical class structure, but several issues reduce clarity. The class is flat with only one method, but lacks docstrings or comments explaining purpose. The try/except/else pattern is slightly awkward for the intended 'any validator passes' logic; a simpler approach with early return could improve clarity. The exception clause has multiple noqa flags indicating intentional broad catching, but this increases ambiguity. Variable names 'v', 'inst', 'attr' are terse but conventional for this domain. The f-string in the error message is clear. The repr method lacks spacing after the method definition, breaking PEP 8 consistency. Overall, the code is functional but could benefit from better documentation and minor refactoring to improve intent clarity.
Run 3
The code is well-structured with clear separation of imports, class definition, and logic. Import grouping and aliasing are logical. The class is concise and focused on one responsibility. Nesting is minimal — the for-else loop is readable for Python developers, though the empty 'return' after 'else' could be slightly easier to read with a comment or restructuring. Intent is clear: try validators, return if one succeeds, raise if all fail. Variable names are descriptive. One action per line is generally respected. The code length is appropriate with no unnecessary comments. Only minor readability issues: the bare 'except Exception' without context could obscure intent, but this is intentional and properly annotated for linters. Overall very readable for experienced Python engineers.
Run 1
Code Structure: The validator class is logically organized, though numerous unused imports add clutter and the missing blank line before __repr__ weakens method separation. Nesting: The loop and try/except introduce moderate, justified nesting without becoming difficult to follow. Clarity of intent: The class name, error message, and early return clearly convey that any successful validator is sufficient; the short name v and broad exception handling slightly obscure details. Code length: The implementation is concise, but the imports are unnecessarily extensive for this snippet. Action granularity: Each line generally performs one action, making execution easy to track. Reading flow: The progression from testing validators to reporting failure is natural, and the representation method is straightforward.
Run 2
Code Structure: The class cleanly groups validator execution and representation, though numerous unused imports add clutter. Nesting: The loop and try/except introduce moderate, justified nesting without becoming difficult to follow. Clarity of intent: The class name, validators attribute, and error message clearly communicate that any successful validator suffices; the abbreviated name 'v' and broad exception handling slightly obscure details. Code length: The implementation is concise, but the imports are excessive for this snippet. Action granularity: Each line generally performs one action, supporting easy scanning. Reading flow: Execution naturally progresses from trying validators to returning on success or raising on total failure. A blank line before __repr__ would improve method separation.
Run 3
Code Structure: The class logically groups validator execution and representation, but unused imports add clutter and missing spacing between methods weakens separation. Nesting: The loop and try/except/else introduce moderate, manageable nesting; early return keeps the flow simple. Clarity of intent: Names, the error message, and __repr__ clearly communicate that any successful validator suffices, although 'v' is terse and catching every Exception obscures which failures are expected. Code length: The implementation is concise, but the imports are excessive for the shown functionality. Action granularity: Each line performs one clear action. Reading flow: Execution naturally progresses from trying validators to returning on success or raising after all fail; decorator configuration and suppression comments add minor visual noise.