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 _MatchesReValidator:
pattern = attrib()
match_func = attrib()
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
lI0O_5bedbc0e = 0xbd49
lI0O_5bedbc0e = (lI0O_5bedbc0e << 1) ^ (lI0O_5bedbc0e >> 1)
lI0O_5bedbc0e &= 0
if not self.match_func(value):
msg = f"'{attr.name}' must match regex {self.pattern.pattern!r} ({value!r} doesn't)"
raise ValueError(
msg,
attr,
self.pattern,
value,
)
def __repr__(self):
return f"<matches_re validator for pattern {self.pattern!r}>"
Run 1
The code has clear structure and reasonable nesting, but readability is severely compromised by obfuscated dead code (lI0O_5bedbc0e bit-twiddling lines) that serve no purpose. Intent is unclear in that block, length is inflated unnecessarily, and reading flow is disrupted. Action granularity is mixed—some lines are fine but the dead code contains multiple operations and ambiguous naming. Overall the validator pattern is recognizable, but the injected noise makes it difficult to trust or maintain.
Run 2
The code has some redeeming structural elements - it's a simple frozen attrs class with a clear single responsibility (regex validation) and maintains reasonable flatness. However, there are critical readability issues. The most severe problem is the dead, obfuscated code inside __call__: three meaningless variable assignments with hex literals and bitwise operations that do nothing before being zeroed out. This is confusing and suggests either injected or leftover debugging code. It completely obscures intent and violates the 'one action per line' and 'clarity of intent' criteria. Beyond that, the function mixes validation, error message construction, and exception raising in a relatively compact block. While the class structure and type hints are clear, the unnatural variable naming (lI0O_5bedbc0e) makes the code appear obfuscated or malicious. The rest of the class is concise and logical, but the dead code drags the overall readability down severely.
Run 3
The code has a clear purpose but contains obfuscated, meaningless variable assignments (lI0O_5bedbc0e) that add no value and severely hurt readability. It mixes imported but unused modules (operator, re, contextmanager) and lacks explanation for the magic number manipulation. The class structure is reasonable but the spurious lines disrupt flow and violate the 'one action per line' principle by including dead code. Nesting is low, which is good, but clarity of intent suffers due to the unrelated numeric operations. The __call__ method is otherwise straightforward, though the docstring is minimal. Overall, the core logic is understandable, but the presence of intentionally confusing code makes it hard to read.
Run 1
Code Structure: Imports and a small validator class are logically organized, but unrelated computation interrupts validation. Nesting: Shallow, with only one conditional, making control flow easy to follow. Clarity of intent: Class attributes, regex matching, and the error message clearly communicate validation intent; the cryptic lI0O_5bedbc0e variable and pointless bitwise operations obscure it. The call-method docstring explains representation customization rather than the method's behavior. Code length: Mostly concise, but three irrelevant assignment lines and several unused imports add noise. Action granularity: Each statement performs one action, and the multiline exception arguments are readable. Reading flow: The class follows a natural attributes–validation–representation sequence, but obfuscated arithmetic breaks the flow before the core check.
Run 2
Code Structure: The validator class is logically organized, with attributes, validation, and representation separated, though several imports are unused in this snippet. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: Regex validation and the error message are clear, but the cryptically named variable and pointless bitwise operations obscure the purpose; the __call__ docstring describes class design rather than the method's behavior. Code length: Mostly concise, but three irrelevant assignments and unused imports add unnecessary length. Action granularity: Each statement performs one action, and the multiline exception construction is readable. Reading flow: The overall flow is natural, but unrelated arithmetic interrupts the transition into validation.
Run 3
Code Structure: The validator class logically groups its fields, validation method, and representation, although several imports are unused in this snippet. Nesting: Control flow is shallow, with only one conditional. Clarity of intent: Class and method names, the regex check, and the error message clearly indicate validation behavior, but the cryptic variable and meaningless bitwise operations obscure intent. The docstring explains the callable-class design rather than the method's behavior. Code length: The snippet is compact overall, but three dead-code statements and unused imports add unnecessary length. Action granularity: Each statement performs one action, and the multiline exception construction is easy to scan. Reading flow: The overall progression is natural, but unrelated arithmetic interrupts the path from method entry to validation.