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, frozen=True, slots=True)
class _NumberValidator:
bound = attrib()
compare_op = attrib()
compare_func = attrib()
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not self.compare_func(value, self.bound):
msg = f"'{attr.name}' must be {self.compare_op} {self.bound}: {value}"
raise ValueError(msg)
def __repr__(self):
return f"<Validator for x {self.compare_op} {self.bound}>"
Run 1
The code is highly readable with clear structure: imports are organized, the class uses a clean attrs-based definition with frozen/slots configuration, and methods are logically separated. Nesting is minimal (one conditional inside __call__), and intent is obvious—a reusable numeric validator with a descriptive error message. Code length is concise without being cryptic; each attribute and method serves a clear purpose. Action granularity is good: one meaningful action per line within the conditional block, and the error construction is straightforward. Reading flow is natural, moving from imports to class definition to method implementations. Minor deductions: the conditional could arguably be inverted for an 'if not' guard, and the docstring in __call__ is slightly redundant, but these are trivial. Overall, it demonstrates strong readability practices.
Run 2
The code is generally readable with a clear structure: imports are organized, the class is decorated with attrs, and each method has a distinct purpose. The __call__ method is concise with minimal nesting and clear logic, although it could be flattened slightly. Action granularity is well-maintained with one logical action per line, and the reading flow is natural. The __repr__ method is succinct but slightly cryptic due to the 'x' placeholder. Minor improvements could include adding type hints and using a more descriptive variable name than 'x'. Overall, the code is maintainable and understandable.
Run 3
The code is highly readable with a clear, focused purpose. It uses a simple frozen/slotted attrs class to implement a numeric validator. Structure is logical: imports, class definition, attributes, core validation method, and repr. Nesting is minimal—just one conditional inside __call__. Intent is explicit: the class name, attribute names, and method names all communicate purpose. Code length is concise without sacrificing clarity. Action granularity is appropriate, with one logical operation per line (comparison, message construction, exception raising). Reading flow is natural: the validation logic moves linearly from input comparison to error message to exception. Minor deductions: the import list could be trimmed (operator, re, Pattern, contextmanager appear unused in the snippet), and the docstring in __call__ explains mechanics rather than the 'why', but neither harms overall readability significantly.
Run 1
Code Structure: The validator is logically organized into attributes, validation behavior, and representation, although several imports are unused in this snippet and spacing between imports and the class is missing. Nesting: Only one conditional level keeps the code easy to follow. Clarity of intent: Descriptive names and informative error messages make the bound comparison clear; the __call__ docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one clear action, and message construction is separated from raising the exception. Reading flow: Attributes followed by __call__ and __repr__ provide a natural progression, with minor visual clutter from the imports.
Run 2
Code Structure: The small validator class logically groups configuration, validation, and representation, although several imports are unused in this snippet and spacing between imports and the class is missing. Nesting: A single conditional keeps control flow shallow. Clarity of intent: Descriptive field names and the error message make numeric-bound validation clear; the call-method docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, with little unnecessary code beyond the unused imports. Action granularity: Each statement performs one action, and error-message construction is separated from raising the exception. Reading flow: Fields followed by validation and representation provide a natural progression, though the decorators and library-specific field declarations require some familiarity.
Run 3
Code Structure: Imports, class attributes, validation logic, and representation are logically organized, though missing blank lines around the class reduce visual separation. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: The class name, comparison fields, and error message clearly communicate numeric-bound validation; however, the docstring explains the callable-class design rather than the method's behavior, and several imports are unused in this snippet. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one clear action, including separate error-message construction and raising. Reading flow: The sequence from configuration fields to validation and representation is natural, although decorator-specific attribute behavior requires some familiarity with the library.