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 clear logical organization: imports are grouped (standard library, typing, then project-specific), and the class uses the attrs decorator idiomatically. Nesting is minimal—only one level of indentation inside the method, with an early return for the None case that improves readability. Intent is clear: this is a validator wrapper that skips validation for None values and delegates otherwise. The __repr__ method is concise and informative. Code length is appropriate; every line serves a purpose. Action granularity is good—each statement is a single logical action. The early return avoids an else block, making the flow natural and easy to follow. Minor deductions: the `_OptionalValidator` name is slightly redundant with the module context, and `self.validator(inst, attr, value)` relies on background knowledge of attrs validator signatures, but this is idiomatic and acceptable in the attrs ecosystem.
Run 2
The code is generally well-structured and readable. It imports necessary modules and defines a single class with clear responsibilities. The class uses the attrs decorator to reduce boilerplate, making the code concise. The __call__ method is flat with minimal nesting and a clear guard clause for None values. The __repr__ method uses an f-string for clarity. However, the code lacks type hints, which could improve intent clarity, and the purpose of the _OptionalValidator class may not be immediately obvious without additional context. The import of contextmanager is unused and should be removed, and combining imports from the same module (e.g., _config) would improve organization. Overall, the code is readable but could benefit from minor cleanup and type annotations.
Run 3
The code is clean and well-structured. It has a single class with one clear responsibility: wrapping a validator to allow None. Nesting is minimal—only one conditional inside the __call__ method. Naming is precise (_OptionalValidator, default_if_none), making intent obvious. The class is concise: three short methods including a clear __repr__. Each method performs one logical action, and line breaks aid readability. Imports are grouped logically, though a few (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, AndValidator, and_, NotCallableError) appear unused in the snippet, slightly reducing clarity. The reading flow is natural: definition, call logic, then representation. Only minor deductions for potentially unused imports and the private naming, which is standard for internal classes but assumes familiarity with attrs conventions.
Run 1
Code Structure: The small class is logically organized, separating validation behavior from representation. Nesting: Minimal nesting and an early return keep the execution path flat. Clarity of intent: The class name and explicit None check clearly communicate optional validation, though inst and attr are abbreviated and the decorator requires library familiarity. Code length: The implementation is concise, but numerous imports are unused in the provided snippet and add clutter. Action granularity: Each statement performs a single action. Reading flow: Execution flows naturally from the None guard to delegated validation, followed by a descriptive representation method. An additional blank line before the class would improve visual separation.
Run 2
Code Structure: Imports and a compact 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, callable interface, and representation clearly convey optional validation; abbreviated parameters and framework-specific decorators require some familiarity. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Methods follow a natural order, with whitespace separating the None guard from validation. A blank line between imports and the class decorator would improve conventional formatting.
Run 3
Code Structure: The small class cleanly groups validation behavior and its representation, though several unused imports add clutter. Nesting: Minimal nesting, with an early return keeping the main validation path flat. Clarity of intent: The class name, delegated validator call, and representation clearly communicate that None is accepted and other values are validated; abbreviated parameters and framework-specific decorators slightly reduce immediate clarity. Code length: The implementation is concise without unnecessary logic, but the import list is excessive for this snippet. Action granularity: Each statement performs one clear action. Reading flow: Imports, class declaration, callable behavior, and representation follow a natural order, with whitespace separating logical steps.