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 (not issubclass(value, self.type)):
pass
else:
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 has severe readability issues. The conditional logic in `__call__` is inverted and confusing: `if not (not issubclass(value, self.type)): pass else: raise` should be a straightforward `if not issubclass(...): raise`. This creates unnecessary nesting and obscures intent. The class structure is acceptable, but the method bodies contain tangled logic. Action granularity is poor in the conditional statement with multiple operations crammed into confusing boolean expressions. The error message construction is clear but buried in the convoluted control flow. The imports appear unused (`operator`, `re`, `Pattern`, `contextmanager`, etc.) suggesting copy-paste or dead code. The docstring is minimal but present. Overall organization follows a logical pattern (validator class with `__call__` and `__repr__`), but the implementation of the core functionality is unnecessarily obfuscated, requiring careful mental parsing to understand the simple check being performed.
Run 2
The code is generally readable but has a confusing control flow in __call__: `if not (not issubclass(...))` followed by `pass` and an `else` block is convoluted and unclear. This structure hurts clarity of intent and action granularity. The class structure is fine, and the imports are concise, though some unused imports (operator, re, Pattern, contextmanager, get_run_validators, etc.) reduce cleanliness. The repr method is clear. Overall, the code is understandable, but the nested negation and inverted if/else make the key validation logic awkward and less readable than it should be.
Run 3
The code has moderate readability issues across several criteria. The structure is logically organized but contains confusing logic: the conditional in `__call__` is unnecessarily convoluted with `if not (not issubclass(...))` which should simply be `if not issubclass(...)`. This creates ambiguity in intent and hurts clarity. Nesting is flat, which is good. The code length is concise. However, action granularity is impacted by the awkward conditional and the multi-line `TypeError` call that could be clearer. Reading flow suffers from the double negative. The imports are somewhat cluttered with unused imports like `operator`, `contextmanager`, `Pattern`, `default_if_none`, and `NotCallableError`, reducing clarity. The validator's purpose is clear but the implementation could be more direct and readable.
Run 1
Code Structure: The validator class is logically organized into state, validation, and representation methods, though unused imports add clutter. Nesting: Nesting is shallow, but the empty success branch and else block are unnecessary. Clarity of intent: Class and method names indicate the purpose, and the error message is informative; however, the double negation in `if not (not issubclass(...))` obscures a simple condition. Code length: The implementation is short, but redundant control flow and unused imports make it longer than needed. Action granularity: Statements generally perform one action per line, and the exception arguments are clearly separated. Reading flow: The overall progression is natural, but the double negation, pass statement, and implementation-focused docstring interrupt straightforward reading. A direct `if not issubclass(value, self.type):` would improve readability substantially.
Run 2
Code Structure: The validator class logically groups its state, validation behavior, and representation, but numerous unused imports add clutter. Nesting: Nesting is shallow, although an empty success branch and an else block are unnecessary. Clarity of intent: Class and method names communicate subclass validation, but the double negation obscures the condition, and the docstring explains the callable-class design rather than validation behavior. Code length: The implementation is short, yet redundant branching and unused imports make it longer than necessary. Action granularity: Statements generally perform one action each, and the multiline exception arguments are easy to distinguish. Reading flow: Organization is conventional, but the inverted condition and pass interrupt natural reading; a direct failing-condition check would make the validation clearer.
Run 3
1. Code Structure: The validator class logically separates validation and representation, but numerous unused imports distract from its small scope. 2. Nesting: Nesting is shallow, although the if/pass/else structure adds an unnecessary branch. 3. Clarity of intent: Class and method names communicate purpose, but the double negation in `if not (not issubclass(...))` obscures a simple condition. The call method's docstring explains the class design rather than validation behavior. 4. Code length: The implementation is short, but redundant imports, the empty success branch, and the expanded exception call add avoidable length. 5. Action granularity: Statements generally perform one action per line, and message construction is separated from raising the exception. 6. Reading flow: Imports, class declaration, validation, and representation follow a conventional order, but the convoluted condition interrupts otherwise straightforward reading.