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 highly readable with clear class structure, descriptive docstrings, and logical organization. The Converter class has a well-defined single responsibility, with methods grouped logically (construction, string formatting, serialization). Nesting is minimal—only simple conditional branches at one level. Intent is explicit through comprehensive docstrings explaining parameters and behavior. Code length is appropriate: the `__init__` method uses a clean if/elif chain to handle different converter signatures, avoiding unnecessary abstraction. Action granularity is good—each line performs one conceptual action, though a few f-strings in `_fmt_converter_call` are slightly long but still readable. Reading flow is natural, moving from initialization logic to helper methods to serialization. The use of type hints, `__slots__`, and `cached_property` imports indicates modern Python practices. Minor deductions: some lambda assignments could be slightly clearer with named functions, and the `__setstate__` docstring could expand on behavior, but these are negligible overall.
Run 3
The code is well-structured, organized logically into a single class with clear separation of concerns. The class docstring is thorough, explaining parameters and behavior. Methods are concise and each performs a single responsibility, with clear naming that communicates intent. Nesting is minimal—only one level in the conditional converter assignment, which is appropriate and readable. The use of lambdas and conditional branches for different converter signatures slightly reduces clarity but is handled cleanly. Line length is generally reasonable, though one f-string line exceeds typical style guides, impacting reading flow. Overall, the code is highly readable with strong documentation, flat structure, and clear intent.
Run 1
Code Structure: The class is logically organized into initialization, call formatting, and serialization methods, with clear separation of responsibilities. 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, although abbreviated variables such as ex and rt, placeholder lambda arguments, and dynamic __call__ assignment require extra interpretation. The __getstate__ docstring omits takes_field despite including it in the returned state. Code length: Methods are concise, but repeated flag combinations, long formatted strings, and numerous imports unused in this excerpt add clutter. Action granularity: Statements generally perform one action per line, and multiline expressions are formatted clearly. Reading flow: The progression from configuration to invocation formatting to persistence is natural, though metaprogramming details and annotation mutation briefly interrupt straightforward reading.
Run 2
Code Structure: Well-organized class with focused methods and helpful docstrings, though numerous unused imports distract in this snippet. Nesting: Mostly flat conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names and documentation explain converter behavior; dynamic __call__ assignment, placeholder lambda parameters, and abbreviations such as 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 flag checks and long formatted strings add some verbosity. Action granularity: Statements generally perform one action each, with no compressed multi-statement lines. Reading flow: Initialization, call formatting, and serialization follow a natural progression, but metaprogramming details and long return lines modestly interrupt readability.
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: Branches remain shallow, and early returns keep formatting logic flat. Clarity of intent: Descriptive method names and detailed docstrings explain the converter's purpose; abbreviated names such as ex and rt, placeholder lambda arguments, and dynamic __call__ assignment require extra attention. The __getstate__ docstring omits takes_field despite its inclusion in the returned state. Code length: Methods are reasonably concise, but repeated flag combinations and generated-call expressions add some duplication. Action granularity: Statements generally perform one action per line, with cleanly separated assignments and returns. Reading flow: The progression from setup to invocation formatting to state handling is natural, though long f-strings and annotation manipulation interrupt otherwise straightforward reading.