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):
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 is generally well-structured and readable. It uses clear naming conventions, logical organization, and flat nesting with minimal indentation levels. The class has a clear purpose, and the methods are concise with appropriate action granularity. The __call__ method is straightforward, and the __repr__ method demonstrates good formatting practices. However, there are minor readability issues: the __call__ method could benefit from a docstring explaining the validation logic, and the conditional in __repr__ could be slightly clearer with a helper method. The code is idiomatic Python with good use of type hints and decorators, but the validation flow could be more explicit. Overall, it strikes a good balance between conciseness and clarity, with minor room for improvement in documentation and separation of concerns within the __repr__ method.
Run 2
The code demonstrates good structure with a well-defined class that has clear responsibilities. The nesting is minimal, with only one level of indentation in the __call__ method. Intent is generally clear, especially with the docstring explaining the design choice of using a callable class. However, the __repr__ method could be clearer about its output format. The code is concise without unnecessary repetition. Action granularity is appropriate - each line performs a distinct operation. Reading flow is somewhat disrupted by the f-string construction in __repr__, which splits the output string across multiple lines. The use of type hints is adequate but could be more explicit. The import structure is organized alphabetically. Overall, the code is readable but could benefit from slightly better documentation and more explicit type annotations.
Run 3
The code is highly readable with clear structure, flat nesting, and logical organization. The class is well-named, uses attrs decorators concisely, and defines two attributes with appropriate validators. The __call__ method performs one action per line, making the control flow obvious: optional iterable validation followed by member iteration and validation. The __repr__ method is clean and readable despite minor string formatting complexity. The code avoids unnecessary length and each component has a clear purpose. Only slight deductions for the conditional f-string construction in __repr__, which requires a moment to parse, and the docstring could be slightly more descriptive. Overall it exemplifies clean, maintainable Python code.
Run 1
Code Structure: The class logically separates configuration, validation, and representation, though several unused imports add clutter. Nesting: Control flow is shallow, with a simple conditional and loop. Clarity of intent: Descriptive names make validation behavior clear, but is_callable() and optional() are not defined or imported in the snippet, and the docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is concise; multiline formatting adds some length but keeps expressions readable. Action granularity: Each statement performs one clear action, with no compressed compound statements. Reading flow: Validation proceeds naturally from the iterable itself to its members, followed by representation logic. The conditional expression and split f-string in __repr__ require minor extra parsing.
Run 2
Code Structure: The class cleanly separates attribute definitions, validation behavior, and representation formatting, though several imports appear unused in this snippet. Nesting: Control flow is shallow, with a simple conditional and loop. Clarity of intent: Descriptive names make iterable and member validation clear; however, is_callable() and optional() are not defined or imported in the shown code, and the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although representation formatting spans several lines. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: The progression from configuration to execution to representation is natural; the multiline conditional expression slightly interrupts an otherwise straightforward flow.
Run 3
Code Structure: The class logically groups validator configuration, validation behavior, and representation, though several imports appear unused in this excerpt. Nesting: Control flow is shallow, with a simple conditional and loop. Clarity of intent: Descriptive names make iterable and member validation clear; however, is_callable() and optional() are not defined or imported in the shown code, and the docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, with modest extra formatting for the representation. Action granularity: Each statement performs one clear action, without compressed or compound operations. Reading flow: Configuration naturally precedes validation and representation; the multiline conditional expression and split f-string slightly interrupt an otherwise smooth flow.