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 well-structured with clear imports, proper use of frozen attrs, and a single-purpose validator class. Nesting is minimal, and each method has a clear intent. The __call__ method handles validation concisely with a clear error message, while __repr__ provides useful debugging info. However, readability could improve with a type hint for 'inst' (likely unused), a more descriptive docstring, and slightly more context around the class purpose. The mix of validation logic and repr in one small class is acceptable but could be separated for clarity. Overall, it's readable and maintainable with only minor improvements needed.
Run 2
The code is generally readable with clear structure and intent. Imports are organized, the class uses attrs decorators effectively, and the __call__ method has a concise validation flow with a clear error message. The repr method improves debuggability. However, readability is slightly reduced by the condensed conditional in __call__—combining validation, message construction, and exception raising into three lines—which could be split for better action granularity. The unused imports (operator, re, Pattern, contextmanager, etc.) add noise and suggest leftover code. Overall, the code is clean and maintainable but could benefit from minor cleanup.
Run 3
The code is highly readable with clear structure and purpose. It defines a frozen, slotted attrs class for numeric validation, using descriptive attributes and a concise __call__ method. Nesting is minimal (one conditional), and each action is on its own line. The imports appear logical though some (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, _AndValidator, and_, default_if_none, NotCallableError) are unused in the shown snippet, slightly reducing clarity about actual dependencies. The docstring and __repr__ enhance intent. Overall, it follows clean, idiomatic Python with strong readability.
Run 1
Code Structure: Imports, class attributes, validation logic, and representation are logically organized, though several imports are unused in this snippet. Nesting: Only one conditional level, making control flow easy to follow. Clarity of intent: The class name, comparison fields, and error message clearly express bounded numeric validation; the __call__ docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, with little unnecessary logic. Action granularity: Each statement performs a single action, and message construction is separated from raising the exception. Reading flow: Attributes precede methods naturally, but additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: The validator is logically organized into attributes, validation behavior, and representation, although numerous unused imports distract from the small class. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: Descriptive names and the error message clearly communicate numeric-bound validation; the docstring explains the callable-class design rather than the validation behavior. Code length: The implementation is concise, but unused imports add unnecessary length. Action granularity: Each line performs a single clear action, with message construction separated from raising the exception. Reading flow: Attributes followed by __call__ and __repr__ provide a natural progression; additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: Imports and a small validator class are logically organized, with validation and representation in separate methods. Nesting: Only one conditional level keeps the code easy to follow. Clarity of intent: Descriptive names and error messages clearly communicate numeric-bound validation, though the docstring explains the callable-class design rather than the method's behavior, and attrs-specific declarations require familiarity. Code length: The implementation is concise, but several imports are unused in the provided snippet. Action granularity: Each statement performs one clear action; message construction and exception raising are appropriately separated. Reading flow: The progression from configuration fields to validation and representation is natural, although an additional blank line before the top-level class would improve visual separation.