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 concise, logically organized, and highly readable. It imports only necessary components and defines a single-purpose callable validator class. The structure is flat with minimal nesting — only one conditional inside `__call__`, which reads clearly. Clarity of intent is strong: the purpose of validating that a value is callable is evident from class and method names, and the docstring explains the design choice. Action granularity is appropriate, with mostly one logical action per line (e.g., message construction, raising the error, returning the repr). The reading flow is natural: imports, class definition, validation logic, then repr override. The only minor weakness is the multi-line string formatting within `raise`, but it remains readable. Overall, this is well-structured, idiomatic Python that would be easy for another developer to understand and maintain.
Run 2
The code is well-structured and readable. It consists of a single focused class with one method and a __repr__ method, clearly separated by action. Nesting is minimal, with only a single conditional inside the __call__ method. The intent is unambiguous: validate that a value is callable and provide a clear error message otherwise. The error message construction is broken into logical lines, improving readability despite slightly longer code. Action granularity is appropriate, with each logical step on its own line. Reading flow is natural: imports, class definition, validator method with clear error handling, then repr. Minor deductions for slight verbosity in the error message formatting, but overall clarity is high.
Run 3
The code is generally well-structured and readable. It uses clear imports, a single class with a focused responsibility, and a logical method flow. The __call__ method is flat, with only one level of nesting for the if statement, which is good. Intent is clear: validating callable attributes. The error message construction is slightly verbose but improves clarity. Minor drawbacks include the multi-line string inside the method, which adds length without much benefit, and the unused imports (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, etc.) which could confuse readers. Overall, the code is concise, actions are separated reasonably, and the reading flow is natural.
Run 1
Code Structure: Imports and a single validator class are logically organized, although several imports appear unused in this snippet. Nesting: The implementation is shallow, with only one conditional and straightforward error construction. Clarity of intent: Descriptive class and exception names, the callable check, and a helpful docstring make the purpose clear; abbreviated parameters and decorator options require some framework familiarity. Code length: The validator is concise without unnecessary logic, though unused imports add clutter. Action granularity: Each statement performs a distinct action, and the multiline message formatting remains readable. Reading flow: Execution naturally progresses from validation to error reporting, followed by the representation method. Slightly more spacing between imports and the class would improve presentation.
Run 2
Code Structure: The validator is logically organized into validation and representation methods, though numerous unused imports distract from its small scope. Nesting: A single conditional keeps nesting shallow; the nested formatting call remains easy to follow. Clarity of intent: Descriptive class naming, the callable check, and a detailed exception clearly communicate the purpose. The docstring explains the class-based design rather than the method's behavior, and abbreviated parameters slightly reduce clarity. Code length: The implementation is concise, with reasonable multiline formatting for the error message. Action granularity: Each statement performs one clear action, with no compressed or semicolon-separated operations. Reading flow: Execution proceeds naturally from checking the value to constructing and raising an informative exception, followed by a simple representation method.
Run 3
Code Structure: Imports and a focused validator class are logically organized, although several imports appear unused in this snippet. Nesting: A single conditional keeps control flow shallow; nested formatting adds only minor visual complexity. Clarity of intent: Descriptive class and method names, a brief explanatory docstring, and a detailed error message make the purpose clear. Code length: The implementation is concise, with reasonable multiline formatting for the exception. Action granularity: Each statement performs one clear action, and arguments are separated for readability. Reading flow: The code moves naturally from validation to error reporting and then representation; framework-specific decorators and exception conventions require some background knowledge.