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 well-structured with clear separation of concerns: imports are organized, the class docstring is thorough, and methods are logically grouped. Nesting is flat—conditional logic in __init__ uses early returns effectively without deep indentation. Intent is explicit: the Converter class wraps callables with optional self/field parameters, and method names like _fmt_converter_call clearly describe their purpose. Code length is appropriate; each method is concise and avoids redundancy (e.g., lambda variants handle parameter combinations cleanly). Action granularity is good—most lines perform one operation, though the conditional lambda assignments pack multiple steps into single lines but remain readable. Reading flow is natural: initialization, state serialization methods, and formatting helpers follow a logical progression. Minor deductions for slightly dense lambda assignments and a few long f-strings, but overall the code is highly readable.
Run 3
The code is well-structured with clear class and method organization. Docstrings explain intent, and the use of __slots__ and lambdas keeps the code concise. Nesting is minimal. However, some methods like _fmt_converter_call contain long f-strings that reduce readability, and the conditional lambda assignments in __init__ could be clearer with a dedicated helper method. Overall, the code is readable but not exemplary.
Run 1
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, although numerous unrelated imports distract from the excerpt. Nesting: Shallow conditional branches and early returns keep complexity manageable. Clarity of intent: Descriptive method names and detailed documentation explain the converter behavior well; abbreviated names such as ex and rt, placeholder parameters, and dynamically assigned __call__ require additional interpretation. The __getstate__ docstring also omits takes_field despite its inclusion in the returned state. Code length: Generally concise, though repeated flag combinations and long formatted strings add some verbosity. Action granularity: Statements typically perform one action per line, with sensible multiline formatting. Reading flow: Methods follow a natural progression and use whitespace effectively, but runtime callable adaptation and generated call strings modestly increase the reader's cognitive load.
Run 2
Code Structure: Methods are logically separated into initialization, call formatting, and serialization, though many imports are unused in this excerpt. Nesting: Shallow conditional chains and early returns keep complexity manageable. Clarity of intent: Descriptive method names and detailed docstrings explain the converter's purpose; dynamically assigning __call__, placeholder lambda parameters, and abbreviations like ex and rt require extra interpretation. The __getstate__ docstring also omits takes_field despite including it in the returned state. Code length: Generally concise, although repeated condition checks and long generated-call strings add some verbosity. Action granularity: Most lines perform one clear action, with lambdas compactly encapsulating argument adaptation. Reading flow: Initialization proceeds naturally from configuration to callable adaptation and annotations, followed by helper and serialization methods; dynamic behavior slightly interrupts otherwise straightforward reading.
Run 3
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, although many imports are unused in this excerpt. Nesting: Shallow conditional branches and early returns keep control flow easy to follow. Clarity of intent: Descriptive names and detailed docstrings explain converter behavior well; dynamically assigning __call__, modifying annotations, and placeholder lambda parameters require extra attention. The __getstate__ docstring omits takes_field despite its inclusion in the returned state. Code length: Mostly concise, though repeated flag combinations and generated call strings add some duplication. Action granularity: Statements generally perform one action per line, with clear multiline formatting. Reading flow: Methods follow a natural progression, but abbreviated names such as ex and rt, long formatted strings, and metaprogramming details modestly interrupt readability.