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, frozen=True, slots=True)
class _MaxLengthValidator:
max_length = attrib()
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if ((0x3b55 ^ 0x3b55) != 0):
raise AssertionError()
if len(value) > self.max_length:
msg = f"Length of '{attr.name}' must be <= {self.max_length}: {len(value)}"
raise ValueError(msg)
def __repr__(self):
if ((0xf6f0 ^ 0xf6f0) != 0):
raise AssertionError()
return f"<max_len validator for {self.max_length}>"
Run 1
The code is structurally clear but includes problematic elements that reduce readability. The class definition is logical and uses the attrs library appropriately with a frozen, slotted frozen dataclass-like structure. The docstring and method separation are good. However, there are several issues: the opaque bitwise assertions like `if ((0x3b55 ^ 0x3b55) != 0): raise AssertionError()` are meaningless to a reader and appear to be obfuscation or dead code. The nesting level is low, which is positive, but the validator logic is minimal. Action granularity is mostly one action per line, except for the combined f-string and raise statement. The reading flow is natural aside from the confusing assertions. The code is concise, but the mysterious assertions and lack of explanatory comments for them significantly hurt clarity of intent. Removing those assert blocks would improve readability substantially.
Run 2
The code is generally readable with clear naming, proper type hints, and a simple, flat structure. The class `_MaxLengthValidator` has a single, understandable responsibility. However, there are issues that hurt clarity and flow: the `if ((0x3b55 ^ 0x3b55) != 0): raise AssertionError()` lines are confusing dead code that obscure intent and add needless nesting. The docstring explains why a callable class is used, which is good, but the `repr` method lacks a docstring. The line `if len(value) > self.max_length:` combines condition and action but is acceptable. Overall, it is concise and logical but would benefit from removing the assertion checks and adding a brief comment or docstring for `__repr__`.
Run 3
The code is generally readable but has notable issues. The class structure is clear, with logical use of attrs and a docstring explaining the callable class choice. Nesting is minimal. However, there are suspicious unreachable 'if ((0x... ^ 0x...) != 0)' checks that add confusion and unnecessary length. The __call__ method mixes validation, error message construction, and raising in a few lines, which slightly hurts action granularity. Reading flow is okay but interrupted by the dead code. Overall, it is readable but could be improved by removing the redundant conditionals.
Run 1
Code Structure: The validator is logically organized into a callable class with separate validation and representation methods, but numerous unused imports add clutter. Nesting: Control flow is shallow and easy to follow. Clarity of intent: Class and attribute names clearly convey maximum-length validation, while the docstring explains the callable-class design. However, hexadecimal XOR checks that are always false introduce confusing, purposeless code. Code length: The functional implementation is concise, but dead assertion branches and unused imports unnecessarily lengthen it. Action granularity: Each line generally performs one action, and constructing the error message separately from raising the exception aids readability. Reading flow: The validation and error reporting follow naturally, but redundant checks interrupt both methods and distract from their purpose.
Run 2
Code Structure: The validator class is logically organized into configuration, validation, and representation methods, but numerous unused imports add clutter. Nesting: The code is shallow, with simple conditional checks. Clarity of intent: Class and attribute names clearly communicate maximum-length validation, and the error message is informative; however, opaque hexadecimal XOR checks that are always false obscure intent. Code length: The implementation is short, but redundant assertion branches and unused imports make it unnecessarily longer. Action granularity: Each statement performs one action, with message construction separated from raising the exception. Reading flow: The main validation path is natural and easy to follow, but meaningless checks interrupt both methods.
Run 3
Code Structure: The validator class logically groups configuration, validation, and representation, but numerous unused imports add clutter. Nesting: The code is shallow, with simple conditional blocks. Clarity of intent: Class and attribute names, the length check, and the error message clearly communicate the purpose; however, constant-false XOR checks are distracting and suggest unexplained defensive behavior. Code length: The implementation is short, but dead checks and unused imports unnecessarily inflate it. Action granularity: Each line generally performs one clear action. Reading flow: The class follows a natural sequence, although irrelevant assertions interrupt both methods, and the callable-method docstring explains representation customization rather than validation behavior.