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, a, b, c):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not issubclass(c, self.type):
d = f"'{b.name}' must be a subclass of {self.type!r} (got {c!r})."
raise TypeError(
d,
b,
self.type,
c,
)
def __repr__(self):
return f"<subclass_of validator for type {self.type!r}>"
Run 1
The code is generally readable: it uses clear naming (_SubclassOfValidator), a single-purpose class, and a concise __call__ method. The structure is flat, with minimal nesting, and each line performs one logical action. The custom __repr__ improves debugging clarity, and the type annotation for `type` is straightforward. However, readability is hindered by the cryptic parameter names `a`, `b`, and `c` in __call__, which obscure intent. The error message construction is slightly awkward due to the f-string and rendering, and the class docstring is minimal despite the unusual callable-class design. Overall, the code is maintainable but could benefit from more descriptive parameter names and a clearer docstring explaining the validator’s role.
Run 2
The code is generally readable with clear intent: a validator class enforcing subclass relationships. The structure is logical, using a callable class and __repr__ override. Nesting is minimal (one 'if' inside __call__). However, parameter names 'a', 'b', 'c' are opaque, obscuring the roles of instance, attribute, and value. The multi-line TypeError construction with 'd' variable is slightly awkward. The class decorator and imports are concise. Overall, readable but could be improved with descriptive parameter names and simplified error raising.
Run 3
The code is moderately readable. It is logically organized with a single class and clear imports. Nesting is shallow, with one conditional inside __call__. The intent of the validator is clear, and action granularity is appropriate—each line does one thing. However, the use of single-letter parameter names (a, b, c) obscures meaning and hurts clarity of intent. The __call__ method bodies are concise, but the exception construction is verbose and could be simplified. The reading flow is natural enough, but the cryptic parameters force the reader to infer context from attribute/validator internals. Overall, it is understandable but not immediately obvious without deeper knowledge of the underlying framework.
Run 1
Code Structure: The validator is logically organized into attribute declaration, validation, and representation methods, though numerous unused imports add clutter. Nesting: A single conditional keeps control flow shallow and easy to follow. Clarity of intent: The class name, issubclass check, and error message clearly communicate the purpose, but generic parameter names a, b, c and temporary variable d obscure their roles. Code length: The implementation is compact, although unused imports and the expanded exception argument list increase its visual length. Action granularity: Each statement performs one clear action. Reading flow: The class reads naturally from configuration to behavior, but sparse spacing around top-level definitions and the repr-focused docstring inside the validation method slightly interrupt the flow.
Run 2
Code Structure: The validator class logically separates validation from representation, but numerous unused imports add clutter. Nesting: A single conditional keeps nesting shallow and easy to follow. Clarity of intent: The class name, issubclass check, and descriptive error message communicate its purpose, while parameter names a, b, c and temporary variable d obscure their roles. The docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although unused imports and the expanded exception arguments add unnecessary visual length. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: The sequence from type declaration to validation and representation is natural, but opaque identifiers and distracting imports interrupt comprehension.
Run 3
Code Structure: The class is logically organized into configuration, validation, and representation methods, although numerous unused imports add clutter. Nesting: A single conditional keeps the validation logic shallow and easy to follow. Clarity of intent: The class name, issubclass check, and error message clearly express the purpose, but parameter names a, b, c and temporary variable d obscure their roles. The docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is compact, though unused imports and the expanded exception arguments introduce some unnecessary length. Action granularity: Each statement performs one clear action, with message construction separated from raising the exception. Reading flow: The progression from checking the value to constructing an error and raising it is natural; descriptive parameter names and import cleanup would improve readability.