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:
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 well-structured and readable. It follows a clean class-based validator pattern with clear logical organization. Nesting is minimal except for a try/except block, which is appropriate for handling TypeError. Naming is consistent and descriptive; variables like `in_options`, `self.options`, and `_original_options` make intent evident. The code is concise without being cryptic, and each line performs a single logical action. The `__call__` method reads naturally: check membership, handle type errors, raise a meaningful error if needed. Error messages are informative and use f-strings clearly. The only minor deductions are the unnecessary `try` block scope (could be narrower) and minor spacing after `except TypeError:`, but these do not significantly impair readability. Overall, it demonstrates strong adherence to Pythonic style and maintainable design.
Run 2
The code is highly readable with clear structure and intent. It defines a single validator class using the attrs library, with logical organization: imports, class definition, initialization via attrib(), and three well-separated methods. Nesting is minimal—only a try/except and an if statement, keeping the logic flat and easy to follow. Each action is on its own line, enhancing clarity. The code is concise without being overly terse, and the error message construction is clear. The validator's purpose is unambiguous: check membership and raise ValueError with helpful context. Minor deductions: the except block silently sets `in_options = False` on a TypeError, which slightly obscures intent (e.g., a brief comment could clarify); also, `_original_options` is stored for error reporting, but this duplication could surprise maintainers. Overall, the reading flow is natural, methods are well-named, and the code exemplifies clean, maintainable design.
Run 3
The code is well-structured and highly readable. It uses a clean class-based validator with clear attribute definitions via `attrs`. The `__call__` method logically separates membership checking, error message construction, and exception raising. Nesting is minimal—only a single try/except and one conditional. Intent is explicit: invalid values raise a descriptive `ValueError`. The code is concise without sacrificing clarity. Action granularity is appropriate, though the multi-line `raise ValueError(...)` call could arguably be compressed. Reading flow is natural, moving from validation logic to error handling to representation. Minor deductions: the blank line containing trailing whitespace after the `except` line is a small formatting issue, and the `msg` variable could be inlined directly into the exception for slightly tighter code.
Run 1
Code Structure: The class is logically organized into attribute declarations, validation, and representation, though several unused imports add clutter. Nesting: Shallow try/except and a single conditional keep complexity low. Clarity of intent: Membership validation is clear from names and the error message; the distinction between options and _original_options is not explained. Code length: The implementation is concise, although the multiline exception construction is slightly verbose. Action granularity: Each statement performs one clear action, with no compressed or compound operations. Reading flow: Validation proceeds naturally from membership checking to error handling, followed by a straightforward representation method. Minor formatting inconsistencies and framework-specific decorators slightly reduce accessibility.
Run 2
Code Structure: The validator class logically groups configuration, validation, and representation, though several unused imports add clutter. Nesting: Control flow is shallow, with a straightforward try/except followed by one conditional. Clarity of intent: Membership validation is clear from names and the descriptive error message; the distinction between options and _original_options is not explained. Code length: The implementation is concise, although the multiline exception construction is somewhat verbose. Action granularity: Each line generally performs a single action, making the code easy to scan. Reading flow: Execution proceeds naturally from the membership check to failure handling, with clear spacing between methods. Framework-specific decorators and attribute declarations require some background knowledge.
Run 3
Code Structure: The class logically separates stored options, validation, and representation, although several imports are unused in this snippet. Nesting: Shallow try/except and a single conditional keep complexity low. Clarity of intent: Membership validation is clear, aided by descriptive names and a useful error message; framework-specific decorators and the distinction between options and _original_options require some context. Code length: The implementation is concise, though unused imports and the expanded exception arguments add minor overhead. Action granularity: Each line generally performs one action, making individual operations easy to identify. Reading flow: Execution proceeds naturally from membership testing to failure handling, followed by representation. Minor formatting issues, including trailing whitespace and limited spacing before the class, slightly reduce polish.