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 _InValidator:
options = attrib()
_original_options = attrib(hash=False)
def __call__(self, inst, attr, value):
try:
in_options = value in self.options
except TypeError: # e.g. `1 in "abc"`
in_options = False
if not in_options:
msg = f"'{attr.name}' must be in {self._original_options!r} (got {value!r})"
raise ValueError(
msg, attr, self._original_options,
value,
)
def __repr__(self):
return f"<in_ validator with options {self._original_options!r}>"
Run 1
The code is generally readable: imports are grouped logically, the class is focused with a single responsibility, and the validator method is relatively flat. Naming is clear (_InValidator, in_options, _original_options). The error message construction is explicit, and the use of attrs decorators keeps boilerplate low. However, several issues reduce readability: the multi-line raise ValueError has inconsistent alignment—arguments are scattered across lines without clear formatting, which disrupts scanning. The closure of __call__ and class body are properly indented, but the overall vertical spacing makes the function feel longer than necessary. Finally, the purpose of _original_options vs options is implied but not documented, leaving intent slightly ambiguous.
Run 2
The code is generally structured and uses clear naming, but several factors reduce readability. The imports are excessive and disorganized (e.g., unused `operator`, `contextmanager`, `Pattern`). The function `__call__` has moderate nesting (try/except inside method, then conditional), but the error-raising block is overly verbose—splitting a single `ValueError` across five lines breaks action granularity and disrupts natural reading flow. The `msg` construction is compact but could be clearer with an f-string on one line. The class is logically organized, and intent is mostly clear, but the excessive import clutter and multi-line exception call make the code feel longer and less focused than necessary.
Run 3
The code is highly readable with clear structure and intent. It uses a simple class with a straightforward validation pattern, minimal nesting (only one try/except and one if), and concise methods. Each action is on its own line, improving clarity. The imports and decorators are well-organized. The error message is explicit and informative. Minor deductions: multiple arguments to ValueError are split across lines with unusual spacing, and the exception comment is slightly informal. Overall, the code is clean and easy to follow.
Run 1
Code Structure: The validator class logically groups its state, validation behavior, and representation, though several imports appear unused in this snippet. Nesting: Shallow try/except and conditional blocks keep complexity low. Clarity of intent: Membership validation is clear from the names, error message, and explanatory TypeError comment; the distinction between options and _original_options is not explained. Code length: The implementation is concise without substantial redundancy. Action granularity: Statements generally perform one action per line, but the oddly spaced exception arguments reduce visual clarity. Reading flow: Validation proceeds naturally from membership testing to error handling, followed by representation; missing separation between imports and the class decorator slightly weakens formatting.
Run 2
Code Structure: The validator class logically groups its state, validation behavior, and representation, but numerous unused imports clutter the snippet. Nesting: Shallow try/except and conditional blocks are easy to follow. Clarity of intent: Membership validation and the TypeError fallback are clear, aided by the example comment; attrs-specific field configuration requires some familiarity. Code length: The implementation is concise, though imports add unnecessary length. Action granularity: Statements generally perform one action per line, but the awkwardly spaced ValueError arguments reduce readability. Reading flow: Execution proceeds naturally from membership testing to failure reporting, although missing spacing before the class decorator and inconsistent argument formatting interrupt the visual flow.
Run 3
Code Structure: The small validator class is logically organized into fields, validation, and representation, although several imports appear unused in this snippet and spacing before the class is missing. Nesting: Shallow try/except and conditional blocks make control flow easy to follow. Clarity of intent: Descriptive names, a helpful TypeError example, and a clear error message communicate membership validation well; the distinction between options and _original_options is not explained. Code length: The implementation is concise without unnecessary logic, though unused imports add clutter. Action granularity: Most lines perform one action, but the irregularly spaced, multiple arguments on one line in the ValueError call reduce readability. Reading flow: Validation proceeds naturally from membership testing to failure reporting, followed by representation; inconsistent formatting slightly interrupts the otherwise smooth flow.