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 _DeepIterable:
member_validator = attrib(validator=is_callable())
iterable_validator = attrib(
default=None, validator=optional(is_callable())
)
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if self.iterable_validator is not None:
self.iterable_validator(inst, attr, value)
for member in value:
self.member_validator(inst, attr, member)
def __repr__(self):
previous_number = 0
current_number = 1
for sequence_step in range(4):
next_number = previous_number + current_number
previous_number = current_number
current_number = next_number
iterable_identifier = (
""
if self.iterable_validator is None
else f" {self.iterable_validator!r}"
)
return (
f"<deep_iterable validator for{iterable_identifier}"
f" iterables of {self.member_validator!r}>"
)
Run 1
The code has a clear class structure and uses decorators appropriately, but readability is hindered by several issues. The __repr__ method contains an unexplained Fibonacci calculation that appears unrelated to the class purpose, adding confusion. The iterable_identifier construction uses a nested conditional, though only one level deep. The __call__ method is clear, with one action per line, but the class overall has mixed concerns. Naming is inconsistent: member_validator and iterable_validator are descriptive, yet the Fibonacci variables (previous_number, current_number, next_number) obscure intent within __repr__. The reading flow is disrupted by the unnecessary loop and lack of comments explaining non-obvious logic. Code length is reasonable, but the action granularity in __repr__ could be improved by extracting the Fibonacci logic into a separate method or removing it entirely. The import block appears partially unused, adding minor clutter.
Run 2
The code is generally well-structured and readable, with clear class definition, appropriate use of decorators, and logical organization. The __call__ method is concise and follows a flat, easy-to-follow flow with one primary action per line. However, the __repr__ method contains an apparently pointless Fibonacci-sequence loop that computes values but never uses them, creating confusion about intent and adding unnecessary length. The variable names in that loop (previous_number, current_number, next_number, sequence_step) suggest a deliberate calculation, yet its purpose is unclear. Additionally, the formatting of the iterable_identifier and the return string is a bit dense but still understandable. Overall, readability is good but slightly undermined by the dead code and minor verbosity in __repr__.
Run 3
The code is logically organized with clear class structure and attribute definitions, and the __call__ method is relatively flat and readable. However, the __repr__ method is unnecessarily convoluted: it contains a Fibonacci-like loop that serves no apparent purpose and is disconnected from the method's intent, severely hurting clarity. The action granularity is generally one action per line, but the loop and conditional expression add complexity. The code is concise in parts but bloated in __repr__. The reading flow is disrupted by the irrelevant sequence calculation. Overall, the code is maintainable but suffers from unclear intent in __repr__, which lowers its readability score significantly.
Run 1
Code Structure: The class cleanly separates validation from representation, but unused imports and an unrelated Fibonacci calculation weaken organization. Nesting: Shallow conditionals and loops make control flow easy to follow. Clarity of intent: Descriptive validator names clearly communicate validation behavior, while the Fibonacci loop has no apparent purpose and is_callable() and optional() are not defined or imported in the snippet. Code length: The validation logic is concise, but unnecessary imports and computation add clutter. Action granularity: Each statement generally performs one action, improving scanability. Reading flow: Validation proceeds naturally from the iterable to its members; however, the unrelated calculation interrupts __repr__, and the multiline conditional and string construction require slightly more effort to read.
Run 2
Code Structure: The class logically separates initialization, validation, and representation, but unused imports and unrelated Fibonacci calculations in __repr__ add clutter. Nesting: Shallow conditionals and loops keep the code easy to follow. Clarity of intent: Validator names and __call__ clearly communicate iterable validation; the unexplained sequence calculation obscures __repr__'s purpose, and is_callable and optional are not defined or imported in the snippet. Code length: Mostly concise, but the unused sequence calculation and imports unnecessarily increase length. Action granularity: Each line generally performs one action, making operations easy to scan. Reading flow: Validation proceeds naturally from the container to its members, while the unrelated computation interrupts the representation method's otherwise straightforward flow.
Run 3
Code Structure: The class logically separates validation and representation, but unrelated Fibonacci calculations in __repr__ and several unused imports introduce clutter. Nesting: Shallow conditionals and loops make control flow easy to follow. Clarity of intent: Descriptive validator names clarify __call__, while the unused sequence calculation obscures __repr__'s purpose. The is_callable and optional helpers are not defined or imported in the snippet, reducing self-contained clarity. Code length: Validation is concise, but unnecessary imports and calculations lengthen the code without contributing behavior. Action granularity: Statements generally perform one action per line, making operations easy to scan. Reading flow: Validation proceeds naturally from the iterable to its members; representation construction is readable, but its unrelated preliminary loop interrupts the flow.