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, step, item, group):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not callable(group):
channel = (
"'{name}' must be callable "
"(got {value!r} that is a {actual!r})."
)
raise NotCallableError(
msg=channel.format(
name=item.name, value=group, actual=group.__class__
),
value=group,
)
def __repr__(self):
return "<is_callable validator>"
Run 1
The code is highly readable. It has a clear, logical structure with a single class containing focused methods. Nesting is minimal, with only one if statement inside the __call__ method. Intent is clear: validate that an item is callable. The code is concise without unnecessary verbosity. Action granularity is good, with each meaningful operation on its own line, though the error message construction spans multiple lines for clarity. Reading flow is natural, moving from import statements to class definition to method implementations. The repr method is appropriately simple. The only minor readability concerns are the multi-line string formatting and the unused imports (operator, re, Pattern, contextmanager, etc.), which could cause slight confusion, but these don't significantly impact the core readability of the validator class itself.
Run 2
The code is well-structured and readable. It uses clear imports, a simple class decorator, and a single `__call__` method with a focused validation check. Intent is explicit: validate that an item is callable and raise a meaningful error otherwise. The error message construction is clear despite being multi-step. Nesting is minimal—only one condition but no deep branches. Each action (check, raise, format) is on its own logical line. The `__repr__` is concise. Minor readability cost comes from the string formatting being split across lines and the use of `group.__class__` instead of a shorter form, but these are minor. Overall the code is clean, maintainable, and easy to follow.
Run 3
The code is quite readable. It uses clear imports, a well-named class, and a single, focused method. The error message construction via a template string and a separate raise statement is clean. The `@attrs` decorator and `__repr__` are concise. Minor deductions for the unused `Pattern` and `operator`/`re` imports which add noise, and the slightly awkward variable name `group` in `__call__` which could be more descriptive (e.g., `value`). Overall, structure is flat, intent is clear, and length is appropriate for its purpose.
Run 1
Code Structure: The validator is logically organized into validation and representation methods, though several unused imports add clutter. Nesting: Only one conditional is used, keeping control flow shallow. Clarity of intent: The class name, callable check, and descriptive exception make the purpose clear, but parameter names such as 'step', 'item', and 'group', plus 'channel' for an error message, are ambiguous. Code length: The implementation is compact, although unused imports and an unused parameter reduce concision. Action granularity: Statements generally perform one action each, and the multiline exception construction is easy to scan. Reading flow: Execution proceeds naturally from checking callability to constructing and raising an error, followed by a simple representation method.
Run 2
Code Structure: The validator class logically groups validation and representation methods, although numerous unused imports add clutter. Nesting: A single conditional keeps control flow shallow; nested formatting calls remain manageable. Clarity of intent: The class name, callable check, and descriptive exception clearly convey the purpose, but parameter names such as step, item, and group, plus channel for an error message, obscure their roles. Code length: The implementation is compact, though the unused imports and a docstring explaining representation rather than validation reduce focus. Action granularity: Statements generally perform one action each, with multiline formatting improving readability. Reading flow: Execution proceeds naturally from checking callability to constructing and raising an error, followed by representation customization; unconventional naming and limited spacing between top-level definitions slightly interrupt that flow.
Run 3
Code Structure: The validator class logically groups validation behavior and its representation, although several unused imports add clutter. Nesting: A single conditional keeps control flow shallow; multiline formatting adds visual depth without complex logic. Clarity of intent: The class name, callable check, and descriptive exception clearly communicate the purpose, but parameter names such as step, item, and group are vague, and channel is misleading for an error-message template. Code length: The implementation is concise, though unused imports and the unused step parameter distract from its core behavior. Action granularity: Statements generally perform one action each, with readable formatting for the exception construction. Reading flow: Execution proceeds naturally from checking callability to constructing and raising an error, followed by a simple representation method. Framework-specific decorators and attributes require some background knowledge.