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 is generally well-structured and readable. It has a clear purpose—defining a validator class—and uses a single class with a single method, keeping the logic flat and avoiding deep nesting. The docstring clarifies intent, and the error message is explicit. Action granularity is good; the class and method each perform focused tasks. However, the import block includes several unused imports (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, and_, attrib, attrs, default_if_none). These extraneous imports add noise, increasing apparent length without contributing to the validator’s functionality. The score reflects strong readability with a minor penalty for unused imports and slight verbosity.
Run 3
The code is well-structured with clear imports, a focused class definition, and a single method that performs one validation task. Nesting is minimal, and the logic is straightforward. The intent is clear: validate that a value is callable and raise a descriptive error otherwise. The error message construction is slightly verbose but aids clarity. One minor readability concern is the inline comment within the __call__ method, which could be placed as a docstring or module-level note. Overall, the code is concise and maintains a natural reading flow.
Run 1
Code Structure: Imports and a focused validator class are logically organized, although several imports are unused in this snippet. Nesting: A single conditional keeps control flow shallow; nested formatting in the exception construction remains manageable. Clarity of intent: The class name, callable check, descriptive error message, and custom representation clearly communicate the purpose. The docstring explains the class-based design, though decorator options require library familiarity. Code length: The implementation is concise, with slightly verbose message construction and unnecessary imports. Action granularity: Each statement performs one distinct action, and multiline formatting improves readability. Reading flow: The code proceeds naturally from validation to failure reporting and then representation; an additional blank line between imports and the class would improve visual separation.
Run 2
Code Structure: The validator is logically organized into a callable validation method and a separate representation method, though several imports appear unused in this snippet. Nesting: A single conditional keeps control flow shallow; multiline exception construction remains easy to follow. Clarity of intent: The class name, callable check, and descriptive error message clearly communicate the purpose. The docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is concise, with modest overhead from unused imports and message formatting. Action granularity: Each statement performs one clear action; multiline arguments improve readability rather than combining unrelated operations. Reading flow: Execution proceeds naturally from checking the value to constructing and raising an informative exception. Additional spacing between imports and the class would improve visual separation.
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 a detailed exception clearly communicate the purpose. The docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is concise, although imports unrelated to this snippet reduce focus. Action granularity: Each statement performs a distinct action, and multiline formatting keeps the exception construction readable. Reading flow: The code proceeds naturally from checking the value to constructing and raising an error, followed by the custom representation. Additional spacing between imports and the class would improve visual separation.