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 has several readability issues. The import section is followed immediately by a class definition without spacing, making the structure feel cramped. The `__call__` method contains a multi-line string and a deeply nested function call with awkward indentation and inconsistent spacing, especially around the `raise NotCallableError` arguments. The method lacks a clear single-purpose flow because error construction and raising are combined in a visually cluttered block. While variable names and the docstring are somewhat clear, the formatting breaks natural reading flow and makes the intent harder to grasp. Overall, the logic is straightforward, but poor layout and dense argument formatting significantly reduce readability.
Run 2
The code is short but has readability issues. It mixes imports, a decorator, and class definition without blank lines. The __call__ method contains a deeply nested raise with awkward multi-line formatting: the NotCallableError call spans four lines with inconsistent indentation and trailing whitespace. The message construction is split unnecessarily, reducing clarity of intent. Action granularity is poor in the raise block, where multiple arguments and formatting are crammed together. Reading flow suffers because the docstring interrupts the logic, and the raise statement's structure forces the reader to backtrack. The __repr__ method is concise and clear. Overall, the code would benefit from better vertical spacing, simplified message construction, and moving the raise call to a cleaner, flatter structure.
Run 3
The code is moderately readable but has several issues. The import section is reasonably organized, and the class definition is clear. However, there is a logical error in the error handling: NotCallableError is raised with the entire dictionary as the msg argument instead of just the formatted string, making the intent ambiguous. The formatting is inconsistent, with excessive spaces and misaligned parentheses in the raise statement. The docstring is helpful but minimal, and the class is concise. The overall structure lacks clear separation between validator logic and error construction. The action granularity is poor in the raise statement, where multiple operations are crammed onto one line. The reading flow is interrupted by these formatting inconsistencies and the logical error. Improvements would include fixing the message passing, aligning arguments properly, and possibly breaking the error construction into smaller steps.
Run 1
Code Structure: The validator class logically groups validation and representation, but imports lack separation from the class and several appear unused. Nesting: Shallow and easy to follow; the single conditional adds little complexity. Clarity of intent: Class and method names clearly communicate callable validation, although the __call__ docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, but unused imports add clutter. Action granularity: Most lines express one action; the awkwardly compressed exception arguments reduce readability. Reading flow: Validation proceeds naturally from checking the value to raising a descriptive exception, but inconsistent spacing, missing blank lines between methods, and malformed-looking argument formatting interrupt the flow.
Run 2
Code Structure: The validator is logically organized into validation and representation methods, but unused imports and missing blank lines add clutter. Nesting: Shallow control flow is easy to follow; only the error-construction expression has additional nesting. Clarity of intent: Class naming, the callable check, and the descriptive error message clearly communicate the purpose, although the docstring explains the design rather than the method's behavior. Code length: The implementation is compact, but the imports are excessive for this snippet. Action granularity: Statements generally perform one action each, though the compressed argument formatting in NotCallableError reduces readability. Reading flow: Execution proceeds naturally from checking the value to raising an error, but inconsistent spacing, crowded closing parentheses, and insufficient separation between methods interrupt the flow.
Run 3
Code Structure: The callable validator class logically separates validation and representation, but unused imports and missing blank lines clutter organization. Nesting: Shallow nesting keeps control flow easy to follow; the multiline exception construction adds minor visual complexity. Clarity of intent: Class and method names, the callable check, and the descriptive error message make the purpose clear. The docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, although several imports are unnecessary for this snippet. Action granularity: Statements generally perform one action each, but placing multiple exception arguments and closing punctuation on one poorly spaced line reduces readability. Reading flow: Validation proceeds naturally from checking the value to reporting failure, followed by representation; inconsistent formatting and tightly packed definitions interrupt that flow.