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, date, step, total):
if total is None:
return
self.validator(date, step, total)
def __repr__(self):
return f"<optional validator for {self.validator!r} or None>"
Run 1
The code demonstrates generally clean structure with logical imports and a straightforward class definition using the attrs library. The class `_OptionalValidator` is concise and its purpose is clear: wrapping another validator to optionally run it when 'total' is not None. However, readability suffers from several issues: the `import` block is scattered with module-level re-imports (`Pattern`, `re`) that are not used within this snippet, creating ambiguity. The parameter names `date`, `step`, and `total` in `__call__` are vague and give no indication of expected types or meaning, reducing clarity of intent. Nesting is flat, which is good, and action granularity is okay—one meaningful action per line in the `__call__` method. The use of `__repr__` via f-string is clear. The overall reading flow is natural, but unused imports and opaque naming lower the score.
Run 2
The code is well-structured into logical imports, class definition, and clearly separated methods. The use of decorators and imports is clean. Nesting is minimal with only one conditional block. Intent is clear from the class name and method names. Code length is concise and appropriate for the functionality. Action granularity is good, with one action per line. Reading flow is natural, progressing from imports to class definition and then to methods. Minor deductions for the slightly opaque parameter names 'date', 'step', and 'total' in __call__, which might be clearer with different naming, and for the lack of type hints that could further improve readability.
Run 3
The code is generally readable but has some clarity issues. The class structure is logical and the use of attrs decorator is clean. However, several aspects reduce readability: the `__call__` method's parameter names (date, step, total) are misleading for a generic optional validator; the import of `operator` and `re` appears unused; the conditional early return in `__call__` creates a slightly awkward flow; and the purpose of `_OptionalValidator` isn't immediately evident from context alone. The nesting is minimal and line length is reasonable, but the semantic mismatch between parameter names and the generic validator purpose makes intent harder to grasp. The mixture of underscore-prefixed imports and public imports also hints at unclear module boundaries.
Run 1
Code Structure: Imports and a single focused class provide clear organization, though several imports are unused. Nesting: The early return keeps control flow flat and easy to follow. Clarity of intent: The class name and methods clearly express optional validation, but the parameter names date, step, and total obscure their roles in a generic validator. Code length: The implementation is concise, with unnecessary imports adding minor clutter. Action granularity: Each statement performs a single action. Reading flow: The progression from declaration to validation behavior to representation is natural; additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: The small class cleanly groups validation behavior and its representation, although numerous unused imports add clutter. Nesting: A single guard clause keeps execution flat and easy to follow. Clarity of intent: The class name, None check, and delegation clearly indicate optional validation, but the parameter names date, step, and total obscure their roles, and attrib() leaves the expected validator interface implicit. Code length: The implementation is concise, with no unnecessary logic; the import block is disproportionate to the shown functionality. Action granularity: Each statement performs one clear action. Reading flow: Imports, class declaration, callable behavior, and representation appear in a natural order, with whitespace separating concerns.
Run 3
Code Structure: The class is logically organized, though numerous unused imports add clutter. Nesting: A simple guard clause keeps control flow flat. Clarity of intent: The class name, None check, and representation clearly communicate optional validation, but parameter names date, step, and total obscure their roles in the validator interface. Code length: The implementation is concise; the import section is unnecessarily long for this snippet. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural progression from configuration to validation behavior to representation, although missing blank-line separation around the imports and class slightly reduces readability.