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 and readable. It uses clear naming conventions, type hints, and docstrings to explain the Converter class's purpose and parameters. The __init__ method's conditional logic for wrapping the converter is relatively flat and each branch performs a single assignment. The helper methods are concise and focused. Minor issues include the complex f-string expressions in _fmt_converter_call, which could benefit from being split into intermediate variables for clarity, and the somewhat magical use of lambda with placeholder underscores (_, __) that may obscure intent for readers unfamiliar with the pattern. Overall, the code is maintainable but has slightly reduced readability due to dense string formatting and subtle lambda conventions.
Run 3
The code is generally well-structured with clear classes, docstrings, and type hints. The Converter class has a logical organization with clear intent in method names. However, there are some readability challenges: the lambda assignments in __init__ create unnecessary complexity with underscore placeholder parameters, and the _fmt_converter_call method has deeply nested conditional returns and very long f-string lines. The __slots__ tuple mixes dunder methods with regular attributes in a way that could be confusing. While the docstrings are thorough and helpful, the conditional lambda logic would benefit from being refactored into named helper methods. Overall the code is maintainable and follows good Python practices, but has room for improvement in reducing nesting depth and line lengths.
Run 1
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, though numerous unused imports clutter this excerpt. Nesting: Shallow conditional branches and early returns keep complexity manageable. Clarity of intent: Descriptive method names and substantial docstrings explain converter behavior well; abbreviated names such as ex and rt, placeholder lambda parameters, and dynamic __call__ assignment require extra interpretation. The __getstate__ docstring also omits takes_field despite its inclusion in the returned state. Code length: Methods are reasonably concise, although argument-selection logic is repeated between initialization and call formatting, and some generated-call strings are long. Action granularity: Statements generally perform one action per line; multiline lambdas remain easy to follow. Reading flow: Methods follow a natural progression, and consistent formatting supports scanning, but runtime annotation modification and string-generated calls introduce some cognitive overhead.
Run 2
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, although many imports are unused in this snippet. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names and detailed docstrings explain the converter's purpose, but abbreviated names such as ex and rt, placeholder lambda parameters, and dynamically assigned __call__ require extra thought. The __getstate__ docstring omits takes_field despite its inclusion in the returned state. Code length: Mostly concise, though repeated flag checks and long formatted strings introduce some verbosity. Action granularity: Statements generally perform one action per line, with multiline expressions formatted clearly. Reading flow: Methods progress naturally from setup to invocation formatting and persistence; annotation handling and generated-call strings add modest cognitive overhead.
Run 3
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, although many imports are unused in this snippet. Nesting: Shallow conditional branches and early returns make control flow easy to follow. Clarity of intent: Descriptive method names and detailed docstrings explain the converter wrapper well, but abbreviations such as ex and rt, placeholder lambda arguments, and dynamically assigned __call__ require extra interpretation. The __getstate__ docstring also omits takes_field despite its inclusion in the returned state. Code length: Generally concise, though repeated flag checks and generated-call expressions add some duplication. Action granularity: Statements typically perform one action per line; multiline lambdas remain understandable. Reading flow: Methods follow a natural progression, with consistent formatting, but long f-strings and dynamic annotation manipulation slightly interrupt readability.