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):
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 demonstrates strong readability through clear structure and organization. The class has a single cohesive purpose with a well-named validator class. Nesting is minimal with just one level in the conditional. The intent is immediately clear - validating subclass relationships. Code length is appropriate for the task, avoiding unnecessary verbosity. Action granularity is good, with each operation on its own logical line. Reading flow is natural, progressing from imports to class definition to method implementations. The error message construction and exception raising are clear. Minor deductions: some imports could be consolidated, and the blank line after the __call__ method signature seems unnecessary. The f-string formatting and type hints are used effectively. Overall, this is exemplary code that would be easy for any Python developer to understand and maintain.
Run 2
The code is relatively clear but has several readability issues. The class structure is simple and logical, with a single responsibility validator. However, the `__call__` method suffers from excessive blank lines and an unnecessarily verbose error-raising block. The error message construction and `raise` statement each span multiple lines, reducing the reading flow. The `issubclass` check is straightforward, but the code could be more concise and easier to scan. Action granularity is inconsistent — some lines handle one action, while the `raise` statement is split across five lines. The absence of a docstring or comments makes intent less obvious to readers unfamiliar with `attrs` validators. Overall, the code is functional and not deeply nested, but formatting choices and lack of concise expression detract from clarity and readability.
Run 3
The code is well-structured and readable. It follows a clear logical organization with a single class definition and appropriate imports. Nesting is minimal, with only one conditional inside the __call__ method. The intent is clear: validating that a value is a subclass of a given type. The code length is concise and appropriately scoped for the task. Action granularity is good—each line performs one logical action, and the error raising is cleanly separated. Reading flow is natural, with the class definition, method implementations, and repr following a logical order. Minor deductions: the blank line after the function signature in __call__ is slightly unusual, and the multi-line error message construction could be slightly simplified, but these are negligible.
Run 1
Code Structure: The validator class logically groups its configuration, validation behavior, and representation, though several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, issubclass check, and descriptive error message clearly communicate subclass validation; abbreviated parameters and the unused inst parameter slightly reduce clarity. Code length: The implementation is concise, although the multiline exception arguments and extra blank line add minor visual overhead. Action granularity: Statements generally perform one action each, with message construction separated from raising the exception. Reading flow: Configuration, validation, and representation follow a natural order, aided by consistent formatting.
Run 2
Code Structure: The validator is logically organized into configuration, validation, and representation methods, though several imports are unused in this snippet. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: The class name, issubclass check, and descriptive error message clearly communicate its purpose; framework-specific decorators and attrib() require some background knowledge. Code length: The implementation is concise, although unused imports and the expanded exception arguments add minor visual overhead. Action granularity: Each statement performs a distinct action, with message construction separated from raising the exception. Reading flow: The progression from declaring the expected type to checking a value and providing a representation is natural; the extra blank line inside __call__ slightly interrupts the flow.
Run 3
Code Structure: The validator class logically separates validation and representation, though several imports are unused in this snippet. Nesting: A single conditional keeps the implementation shallow and easy to follow. Clarity of intent: Descriptive class naming, issubclass, and a precise error message clearly convey the purpose; attrs-generated initialization requires some library familiarity. Code length: The implementation is concise, although unused imports and the expanded exception arguments add minor visual overhead. Action granularity: Each statement performs one clear action, with message construction separated from raising the exception. Reading flow: Imports, class declaration, validation, and representation follow a natural order; the extra blank line inside __call__ slightly interrupts the flow.