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=True, unsafe_hash=True)
class _SubclassOfValidator:
type = attrib()
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not issubclass(value, self.type):
raise TypeError(
(f"'{attr.name}' must be a subclass of {self.type!r} (got {value!r})."),
attr,
self.type,
value,
)
def __repr__(self):
return f"<subclass_of validator for type {self.type!r}>"
Run 1
The code is highly readable due to its clear structure, flat nesting, and concise implementation. It follows a logical organization with imports, class definition, and methods in a natural order. The single-level nesting in __call__ keeps the logic straightforward, and the use of a docstring clarifies intent. The __repr__ method is concise and informative. Minor deductions arise from the slightly verbose error message formatting that could be split for readability and the unused imports (operator, re, Pattern, contextmanager, and get_run_validators) that add noise without affecting function. Overall, the code is well-structured and easy to understand.
Run 2
The code is generally readable with clear structure and intent. It uses a class as a validator, imports are organized, and the __call__ method has a straightforward flow. Nesting is minimal, and action granularity is reasonable. However, there is an unnecessary blank line before the raise statement, and the TypeError arguments could be slightly clearer. The docstring is helpful but concise. The code length is appropriate, and the reading flow is natural. Overall, it is fairly readable but could benefit from minor formatting cleanup and slightly more explicit error handling context.
Run 3
The code is well-structured and readable. Import organization is clean, with standard library, third-party, and local imports grouped logically. The class definition is concise with appropriate use of the `attrs` decorator for boilerplate reduction. The `__call__` method has a clear single responsibility: validating subclass relationships. Nesting is minimal—only one conditional with an early raise, maintaining flat structure. The error message is informative and readable, though the multi-line f-string with tuple arguments could be slightly flattened. Action granularity is appropriate, with one logical action per line except for the raise statement which bundles several related values. The docstring succinctly explains the design choice of using a callable class. The `__repr__` method is clear and returns a descriptive string. Minor deductions are for the unnecessary blank line before the raise and the slightly dense error message construction, but overall this is well-crafted, maintainable code with clear intent.
Run 1
Code Structure: The validator is logically organized into initialization metadata, validation behavior, and representation, though several imports are unused in this snippet. Nesting: Minimal nesting makes the control flow easy to follow. Clarity of intent: The class name, issubclass check, and descriptive error clearly communicate its purpose; however, the call-method docstring explains representation customization rather than validation, and abbreviated parameters slightly reduce clarity. Code length: The implementation is concise, with minor unnecessary parentheses and whitespace. Action granularity: Each statement performs a single clear action, and the multiline exception arguments remain readable. Reading flow: The sequence is natural and straightforward, but the blank line before raise and limited separation around top-level definitions slightly weaken formatting consistency.
Run 2
Code Structure: Imports and a small validator class are logically organized, though several imports are unused in this snippet. Nesting: Shallow nesting makes control flow easy to follow. Clarity of intent: Class and method names clearly convey subclass validation, and the error message is informative; however, the __call__ docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is concise, with minor clutter from an unnecessary blank line and redundant parentheses around the f-string. Action granularity: Each statement performs one clear action, and the exception arguments are neatly separated. Reading flow: The progression from configuration to validation to representation is natural, although framework-specific decorators and attrib() require some background knowledge.
Run 3
Code Structure: The validator is logically organized into an attribute, validation method, and representation method, though several unused imports add clutter. Nesting: Only one conditional level keeps the code easy to follow. Clarity of intent: The class name, issubclass check, and descriptive error make its purpose clear; however, the __call__ docstring explains the callable-class design rather than validation behavior. Code length: The implementation is concise, with minor unnecessary parentheses and a stray blank line. Action granularity: Each statement performs one clear action, and the multiline exception arguments are readable. Reading flow: The progression from configuration to validation to representation is natural, slightly disrupted by excess imports and inconsistent whitespace.