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):
msg = f"'{attr.name}' must be a subclass of {self.type!r} (got {value!r})."
raise TypeError(
msg,
attr,
self.type,
value,
)
def __repr__(self):
return f"<subclass_of validator for type {self.type!r}>"
Run 1
The code is highly readable with clear structure, minimal nesting, and concise length. It demonstrates logical organization with a single class defined using the attrs decorator. The nesting depth is shallow (one conditional within one method), maintaining an easy-to-follow flow. Intent is unambiguous — a validator ensuring a value is a subclass of a specified type. Action granularity is appropriate; the conditional check, exception raising, and repr methods each perform coherent actions. Reading flow is natural, with type hints, docstring, and f-strings improving clarity. Minor points could be made about one-line methods or slightly more descriptive parameter names, but overall it is excellent.
Run 2
The code is highly readable with clear structure, minimal nesting, and concise implementation. It follows a logical organization: imports, class definition, constructor, call method, and repr. Each method has a single responsibility with flat control flow. The docstring clarifies the design decision for using a callable class. Error message formatting is clean and informative. Type hints and named imports improve clarity. The only minor deductions are for the multi-line function call in the raise statement and slightly verbose import block, but these do not significantly impact readability. Overall, the code is maintainable and easy to understand.
Run 3
The code is well-structured and readable. It uses clear class-based design with a single responsibility for _SubclassOfValidator. Nesting is minimal, with only one conditional inside the __call__ method. Intent is clear: validate subclass relationships. The code is concise without sacrificing clarity. Action granularity is appropriate, with each logical step separated. Reading flow is natural, moving from imports to class definition to method implementations. Type hints and docstrings are present but minimal. The only minor deductions are for the slightly awkward error message construction and the lack of a full docstring explaining the validator's purpose beyond the repr comment. Overall, the code follows good Python practices and is easily understandable.
Run 1
Code Structure: Imports and a small validator class are logically organized, though several unused imports add clutter. Nesting: A single conditional keeps control flow shallow and easy to follow. Clarity of intent: The class name, subclass check, error message, and custom representation clearly communicate its purpose; the docstring explains the callable-class design, although abbreviated parameter names and framework-specific decorators require some context. Code length: The implementation is concise, but the multiline exception construction is slightly verbose. Action granularity: Each statement performs one clear action. Reading flow: The progression from configuration to validation to representation is natural, with appropriate whitespace and no tangled logic.
Run 2
Code Structure: Imports and a small validator class are logically organized, though several imports are unused in this snippet. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: The class name, subclass check, and descriptive error message clearly communicate the purpose; the docstring explains the callable-class design rather than validation behavior. Code length: The implementation is concise, although the multiline exception arguments add some unnecessary vertical space. Action granularity: Each statement performs one clear action, with message construction separated from raising the exception. Reading flow: Methods follow a natural order, and formatting is consistent, but framework-specific decorators and attribute declarations require some background knowledge.
Run 3
Code Structure: Imports and a single validator class are logically organized, although several imports are unused in this snippet. Nesting: Shallow nesting makes the validation path easy to follow. Clarity of intent: The class name, subclass check, descriptive error message, and custom representation clearly convey its purpose; the docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is concise, though unused imports and the expanded exception construction add minor overhead. Action granularity: Each statement performs one clear action. Reading flow: The progression from declaration to validation to representation is natural, with modest familiarity with attrs required to understand the generated initialization and stored type.