Source code
from __future__ import annotations
import abc
import contextlib
import enum
import itertools
import linecache
import sys
import types
import unicodedata
import weakref
from collections.abc import Callable, Mapping
from functools import cached_property
from typing import Any, NamedTuple, TypeVar
from . import _compat, _config, setters
from ._compat import (
PY_3_11_PLUS,
PY_3_13_PLUS,
_AnnotationExtractor,
_get_annotations,
_lazy_is_generator,
get_generic_base,
)
from .exceptions import (
DefaultAlreadySetError,
FrozenInstanceError,
NotAnAttrsClassError,
UnannotatedAttributeError,
)
class Converter:
"""
Stores a converter callable.
Allows for the wrapped converter to take additional arguments. The
arguments are passed in the order they are documented.
Args:
converter (Callable): A callable that converts the passed value.
takes_self (bool):
Pass the partially initialized instance that is being initialized
as a positional argument. (default: `False`)
takes_field (bool):
Pass the field definition (an :class:`Attribute`) into the
converter as a positional argument. (default: `False`)
.. versionadded:: 24.1.0
"""
__slots__ = (
"__call__",
"_first_param_type",
"_global_name",
"converter",
"takes_field",
"takes_self",
)
def __init__(self, converter, *, takes_self=False, takes_field=False):
self.converter = converter
self.takes_self = takes_self
self.takes_field = takes_field
ex = _AnnotationExtractor(converter)
self._first_param_type = ex.get_first_param_type()
if not (self.takes_self or self.takes_field):
self.__call__ = lambda value, _, __: self.converter(value)
elif self.takes_self and not self.takes_field:
self.__call__ = lambda value, instance, __: self.converter(
value, instance
)
elif not self.takes_self and self.takes_field:
self.__call__ = lambda value, __, field: self.converter(
value, field
)
else:
self.__call__ = self.converter
rt = ex.get_return_type()
if rt is not None:
self.__call__.__annotations__["return"] = rt
@staticmethod
def _get_global_name(attr_name: str) -> str:
"""
Return the name that a converter for an attribute name *attr_name*
would have.
"""
return f"__attr_converter_{attr_name}"
def _fmt_converter_call(self, attr_name: str, value_var: str) -> str:
"""
Return a string that calls the converter for an attribute name
*attr_name* and the value in variable named *value_var* according to
`self.takes_self` and `self.takes_field`.
"""
if not (self.takes_self or self.takes_field):
return f"{self._get_global_name(attr_name)}({value_var})"
if self.takes_self and self.takes_field:
return f"{self._get_global_name(attr_name)}({value_var}, self, attr_dict['{attr_name}'])"
if self.takes_self:
return f"{self._get_global_name(attr_name)}({value_var}, self)"
return f"{self._get_global_name(attr_name)}({value_var}, attr_dict['{attr_name}'])"
def __getstate__(self):
"""
Return a dict containing only converter and takes_self -- the rest gets
computed when loading.
"""
return {
"converter": self.converter,
"takes_self": self.takes_self,
"takes_field": self.takes_field,
}
def __setstate__(self, state):
"""
Load instance from state.
"""
self.__init__(**state)
Run 1
The code is well-structured and readable. It uses clear class design with slots, docstrings, and named parameters. The Converter class has a logical flow, and methods are concise with single responsibilities. Nesting is flat, intent is clear, and action granularity is appropriate. Minor issues include the lambda assignments in __init__ which slightly reduce clarity, and the long f-string lines in _fmt_converter_call could be reformatted for better readability.
Run 2
The code is generally well-structured with clear class and method boundaries, docstrings, and consistent use of type hints. The Converter class has a focused purpose and the methods are mostly single-purpose. However, readability is reduced by the dynamic assignment of __call__ via lambdas in __init__, which obscures the call behavior and makes it harder to trace execution. The _fmt_converter_call method contains somewhat long f-strings with multiple arguments, but remains understandable. Nesting is minimal and the reading flow is mostly natural. The code is concise but not overly compressed, with reasonable line lengths and use of blank lines. Overall, it is quite readable, though the lambda-based __call__ assignment and one long f-string slightly detract from clarity.
Run 3
The code is generally well-structured with clear class organization, imports, docstrings, and type hints. The Converter class uses slots and a clean __init__ that assigns responsibilities logically. Nesting is minimal and readable. The lambda-based __call__ assignments are concise but somewhat subtle—readers must track conditional logic across multiple branches to determine which call signature is active. The _fmt_converter_call method uses somewhat long f-strings and repeated conditional checks, which slightly impacts scanning and readability. Action granularity is mostly good, with one main action per line, though a few long lines break this. Naming is consistent and intent is mostly clear. The use of __getstate__/__setstate__ and _AnnotationExtractor adds abstraction that may require domain knowledge but is documented. Overall, readability is high but slightly reduced by conditional lambda assignments and long f-string expressions.
Run 1
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, though the extensive imports distract from the focused snippet. Nesting: Conditional branches are shallow, and early returns keep formatting logic flat. Clarity of intent: Descriptive method names and detailed docstrings explain converter behavior well; abbreviated names such as ex and rt, placeholder lambda parameters, and dynamic __call__ assignment require closer reading. Code length: Methods are reasonably concise, although argument-selection logic is repeated and some formatted strings are long. Action granularity: Statements generally perform one action per line, with multiline calls aiding readability. Reading flow: The progression from setup to helper methods and state handling is natural. Minor distractions include the unused _global_name slot and a __getstate__ docstring that omits takes_field despite its inclusion in the returned dictionary.
Run 2
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, though many imports are unused in this excerpt. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names and detailed docstrings explain the converter behavior well; abbreviated names such as ex and rt, placeholder lambda parameters, and dynamic __call__ assignment require extra interpretation. Code length: Mostly concise, but repeated flag checks and long formatted strings add some verbosity. Action granularity: Statements generally perform one action per line, with multiline lambdas remaining readable. Reading flow: Methods follow a natural progression, although annotation manipulation and generated call strings introduce complexity. The __getstate__ docstring omits takes_field despite its inclusion in the returned state.
Run 3
Code Structure: The class is logically organized into initialization, converter-call formatting, and serialization methods, although many imports are unused in this excerpt. Nesting: Shallow conditional branches and early returns keep complexity manageable. Clarity of intent: Descriptive method names and detailed docstrings explain the converter options well; dynamic __call__ assignment, placeholder lambda arguments, and abbreviated names such as ex and rt require extra interpretation. The __getstate__ docstring also omits takes_field despite its inclusion in the returned state. Code length: Methods are reasonably concise, though repeated flag checks and generated-call expressions introduce some duplication. Action granularity: Statements generally perform one action per line, with readable multiline formatting. Reading flow: The progression from setup to invocation formatting to state handling is natural; long f-strings and dynamic annotation manipulation slightly interrupt readability.