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=False, unsafe_hash=True)
class _IsCallableValidator:
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not callable(value):
message = (
"'{name}' must be callable "
"(got {value!r} that is a {actual!r})."
)
raise NotCallableError(
msg=message.format(
name=attr.name, value=value, actual=value.__class__
),
value=value,
)
def __repr__(self):
return "<is_callable validator>"
Run 1
The code is well-structured and highly readable. Imports are organized, the class uses a decorator for concise setup, and the `__call__` method has a clear purpose with a helpful docstring. The error message construction is logical and the validation logic is straightforward. There is one action per line and minimal nesting. The `__repr__` method is simple and explicit. Minor points deducted because the multi-line message string with `.format()` is slightly verbose, and the `msg=` keyword in `NotCallableError` adds a small amount of noise, but overall the code is clean, intent-revealing, and easy to follow.
Run 2
The code demonstrates excellent readability through clear imports, logical organization, and flat structure. The class has a single responsibility and minimal nesting, with only one level of indentation inside the `__call__` method. Intent is explicit through descriptive naming (`_IsCallableValidator`, `NotCallableError`) and helpful docstrings. The error message construction is well-formatted and readable. Code length is concise without sacrificing clarity. Each line performs one logical action, and the reading flow follows a natural progression from validation to error raising to representation. Minor deductions: the `@attrs` decorator line is dense with arguments, and the method signature spans three lines unnecessarily. Overall, this is production-quality readable code.
Run 3
The code is well-structured and concise. It imports only necessary modules, defines a single validator class with clear responsibilities, and uses a callable class with a sensible docstring explaining design intent. The __call__ method follows a flat conditional flow with no deep nesting. Error message construction is clean and readable, with clear variable naming. The __repr__ method is trivial and clear. Minor deductions: the conditional error message block could be slightly more compact, and the overall module context is missing, but within the snippet the reading flow is natural and intent is obvious.
Run 1
Code Structure: Imports and a small validator class are logically organized, although several imports are unused in this snippet. Nesting: A single conditional keeps control flow shallow; nested formatting calls remain easy to follow. Clarity of intent: The class name, callable check, descriptive error, and custom representation clearly communicate the purpose. The docstring explains the class-based design, though decorator options require familiarity with the library. Code length: The implementation is compact, with reasonable multiline formatting for the error construction. Action granularity: Each statement performs one clear action, and keyword arguments are separated cleanly. Reading flow: The code progresses naturally from validation to error reporting and representation. A blank line between imports and the decorator would improve visual separation.
Run 2
Code Structure: The validator is logically organized into validation and representation methods, though numerous unused imports add clutter. Nesting: Control flow is shallow, with a single conditional; multiline formatting introduces no substantial complexity. Clarity of intent: The class name, callable check, and descriptive exception clearly communicate the purpose. The docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although the imports are excessive for this snippet. Action granularity: Each statement performs one clear action, and exception arguments are neatly separated. Reading flow: Validation progresses naturally from checking the value to constructing and raising an informative error, followed by a simple representation method.
Run 3
Code Structure: The validator is logically organized into validation and representation methods, though several unused imports add clutter. Nesting: Control flow is shallow, with a single conditional; nested formatting calls remain easy to follow. Clarity of intent: Descriptive class and method names, a straightforward callable check, and an informative exception clearly communicate purpose. The docstring explains the callable-class design rather than the validation behavior. Code length: The implementation is concise, although unused imports slightly inflate it. Action granularity: Statements perform distinct actions, and multiline exception construction improves readability. Reading flow: The code progresses naturally from checking the value to constructing and raising an error, then defining its representation. Additional blank-line separation after imports would improve visual organization.