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 _OptionalValidator:
validator = attrib()
def __call__(self, inst, attr, value):
if value is None:
return
self.validator(inst, attr, value)
def __repr__(self):
return f"<optional validator for {self.validator!r} or None>"
Run 1
The code is well-structured with a clear class definition using the attrs library. Imports are organized, though some unused imports (operator, re, Pattern, contextmanager) slightly reduce clarity. The class has a clear purpose as an optional validator. Nesting is minimal with only one conditional check. The `__call__` method is concise and the logic is straightforward - if value is None, skip validation; otherwise delegate to the wrapped validator. The `__repr__` provides helpful debug information. Action granularity is good with one action per line. Reading flow is natural from imports through class definition to methods. Minor deductions for unused imports and the slightly cryptic parameter names (inst, attr, value) which could be more descriptive, though these follow common attrs validator conventions.
Run 2
This code is highly readable. It has a clear structure, with imports organized logically and a single class definition. The nesting is minimal, and the intent of each method is straightforward. The code is concise, avoiding unnecessary length. Action granularity is appropriate—each line performs a distinct action, and the reading flow is natural. The use of type hints and docstrings-like comments would improve it slightly, but overall it is very clean and maintainable.
Run 3
The code is generally clear and well-structured. It imports necessary modules and defines a single class with a clear purpose: a validator that allows None or delegates to another validator. The class uses the attrs decorator to reduce boilerplate. Nesting is minimal—only one level inside __call__. Each action is on its own line, and naming is descriptive. The main opportunity for improvement is the mix of import styles (redundant 'import re' and 'from re import Pattern') and the unused contextmanager import. Also, the __call__ method lacks a docstring, which would clarify intent. Still, the code is concise, readable, and follows common Python patterns.
Run 1
Code Structure: Imports and the validator class are logically organized, though several imports are unused in the shown snippet. Nesting: Minimal; an early return avoids unnecessary nesting. Clarity of intent: The class name, delegation, and descriptive repr clearly communicate optional validation, although inst and attr are abbreviated and the attrs configuration requires familiarity with the library. Code length: The implementation is concise, with little unnecessary code beyond unused imports. Action granularity: Each statement performs one clear action. Reading flow: The code flows naturally from declaration to validation behavior to representation; an extra blank line between imports and the class would improve visual separation.
Run 2
Code Structure: Imports and a small validator class are logically organized, though several imports are unused in this snippet. Nesting: Minimal nesting and an early return keep execution straightforward. Clarity of intent: The class name, None check, delegated validation, and descriptive representation clearly communicate optional validation; abbreviated parameters and framework-specific decorators require some familiarity. Code length: Concise, with no unnecessary logic, although unused imports add clutter. Action granularity: Each line performs one clear action. Reading flow: Methods follow a natural progression from stored validator to invocation behavior and representation; an additional blank line between imports and the class would improve visual separation.
Run 3
Code Structure: Imports and a small validator class are logically organized, though several imports are unused in this snippet. Nesting: Minimal nesting and an early return keep control flow flat. Clarity of intent: The class name, None check, and delegation clearly convey optional validation; the decorator and attrib() require familiarity with the supporting library. Code length: Concise, with no unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Methods progress naturally from validation behavior to representation, although an additional blank line between imports and the class would improve visual separation.