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, a, b, c):
for d in self.validators:
try:
d(a, b, c)
except Exception: # noqa: BLE001, PERF203, S112
continue
else:
return
e = f"None of {self.validators!r} satisfied for value {c!r}"
raise ValueError(e)
def __repr__(self):
return f"<or validator wrapping {self.validators!r}>"
Run 1
The code has reasonable structure with a single class declaration and clear import organization, but readability suffers from poor naming conventions. Variables 'a', 'b', 'c', 'd', and 'e' are cryptic and give no indication of their purpose, violating clarity of intent. The `__call__` method uses a try/except/else pattern that, while flat and not deeply nested, obscures the logic flow—the 'continue on exception, return on success' pattern could be clearer. The method signature with three parameters and exception handling inside a loop makes the action granularity unclear. On the positive side, the code is concise, has flat nesting, and the class structure with `attrs` decorator is logical. The repr method is simple and clear. Overall, the code is maintainable but would benefit significantly from descriptive variable names and clearer comments or logic restructuring.
Run 2
The code shows reasonable structure with clear class definition and logical method organization. Nesting is minimal with only one level within the for loop and try/except block. Intent is generally clear, though single-letter variables (a, b, c, d, e) reduce clarity significantly - these could be named more descriptively like self, attribute, value, validator, error_msg. Code length is concise and action granularity is appropriate with one action per line. Reading flow is natural with validation logic flowing from iteration to exception handling. The main deductions come from unclear variable naming and slightly opaque error message construction. The contextmanager imports and some unused imports (operator, re, Pattern, etc.) appear unnecessary for this snippet, potentially indicating broader module complexity. Overall, readable but could benefit from better variable names.
Run 3
The code imports are clean and organized, and the class structure is logical with clear responsibility. The __call__ method is relatively flat with only one nesting level in the try/except/else. However, readability suffers from non-descriptive variable names like a, b, c, d, and e, which obscure intent. The __repr__ method is concise and clear. Action granularity is mostly one action per line, but the f-string and return statements could be split for clarity. The validation loop logic is understandable yet could benefit from a helper or more explicit naming. Overall, the structure is decent but variable naming and slightly compressed logic reduce clarity.
Run 1
Code Structure: The validator class is logically organized into validation and representation methods, though numerous unused imports add clutter. Nesting: The loop and try/except/else introduce moderate nesting, but the short body remains easy to follow. Clarity of intent: The class name, validators field, and error message convey OR-style validation, but single-letter parameters and local variables obscure their roles. Catching every Exception also leaves the intended failure handling ambiguous. Code length: The implementation is concise, although imports and an intermediate error-message variable add unnecessary length. Action granularity: Each line generally performs one action, with no compressed statements. Reading flow: Validation proceeds naturally through candidates, returns on success, and raises after all fail; opaque names and the dense suppression comment slightly disrupt readability.
Run 2
Code Structure: The small class logically groups validation behavior and its representation, but numerous unused imports distract from its purpose. Nesting: The loop and try/except/else introduce moderate nesting, though continue and return keep execution straightforward. Clarity of intent: _OrValidator, validators, and the error message communicate the overall purpose, but single-letter parameters and local variables obscure their roles. Catching every Exception also makes intended failure handling ambiguous. Code length: The implementation is concise, although the imports add unnecessary bulk. Action granularity: Each line generally performs one action, making individual operations easy to follow. Reading flow: The progression from trying validators to returning on success or raising on total failure is natural; cryptic names and the dense suppression comment slightly interrupt readability.
Run 3
Code Structure: The class is logically organized into state, validation behavior, and representation, although several imports are unused in this snippet. Nesting: The loop and try/except/else introduce moderate nesting, but the early return keeps control flow manageable. Clarity of intent: The class name, validators field, and error message communicate that any validator may succeed; however, single-letter parameters and local variables obscure their roles, and catching every Exception blurs expected validation failures versus unexpected errors. Code length: The implementation is compact without substantial unnecessary code beyond unused imports. Action granularity: Statements generally perform one action per line. Reading flow: The progression from trying validators to returning on success or raising after all failures is natural, though meaningful variable names would make it easier to follow.