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.
"""
lI0O_247fe2c7 = ((0xc74a ^ 0xc74a) != 0)
lI0O_247fe2c7 = not (not lI0O_247fe2c7)
self.__init__(**state)
Run 1
The code is generally well-structured with clear separation of concerns, good docstrings, and moderate use of type hints. The Converter class has logical organization and the __init__ method uses flat conditional logic that is reasonably readable. However, readability is undermined by several issues: the generated converter call strings in _fmt_converter_call are excessively long lines that mix logic across multiple actions; the lambda assignments in __init__ sacrifice clarity for conciseness; and the final obfuscated variable names (lI0O_247fe2c7) in __setstate__ are severely detrimental to readability. Nesting is minimal and action granularity is mostly one action per line, but the reading flow is disrupted by the jarring transition from clear code to obfuscated pseudo-logic. Overall, the code is maintainable in most parts but contains unnecessary complexity and obscurity that lower its score.
Run 2
The code is generally well-organized: the `Converter` class has a clear docstring, logical field definitions, and functional methods. However, readability is significantly degraded by several factors. The use of positional underscores (_, __) in lambda calls creates ambiguity about what's being passed. The `_fmt_converter_call` method has three long f-string return lines, which could be made clearer. The `__getstate__`/`__setstate__` methods are straightforward, but `__setstate__` contains obfuscated variable names (`lI0O_247fe2c7`) and meaningless boolean assignments that serve no apparent purpose, breaking the otherwise clean style. Nesting is minimal and action granularity is acceptable, but the obfuscated logic and variability of style pull the score down. The class exhibits good intent and documentation but suffers from unclear lambda signatures and unexplained complex conditionals, making it harder to follow.
Run 3
The code is generally well-structured with clear class documentation, logical organization, and reasonable method lengths. The Converter class has a clear purpose and the docstrings explain the parameters well. Nesting is minimal and the code flow is natural. However, there are a few readability issues: the __setstate__ method contains obfuscated variable names (lI0O_247fe2c7) that appear to be auto-generated or intentionally confusing, which hurts clarity. Some lines in _fmt_converter_call are quite long, reducing readability. The lambda assignments in __init__ are somewhat dense but acceptable given the clear branching logic. Overall, the code demonstrates good practices but has minor maintainability concerns.
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 conditionals and early returns keep complexity manageable. Clarity of intent: Descriptive method names and docstrings explain converter behavior, but abbreviated variables, placeholder lambda parameters, and meaningless obfuscated assignments in __setstate__ undermine clarity. The __getstate__ docstring also omits takes_field despite returning it. Code length: Generally concise, but repeated formatting expressions and dead assignments add unnecessary length. Action granularity: Most lines perform one action; lambdas and formatted strings remain reasonably focused. Reading flow: Methods follow a natural progression, although long return expressions and the unexplained boolean manipulation interrupt otherwise straightforward reading.
Run 2
Code Structure: Methods are logically grouped within a focused class, although many imports are unused in this excerpt. Nesting: Conditional branches are shallow and easy to follow. Clarity of intent: Descriptive method names and detailed docstrings explain converter behavior, but abbreviated variables, placeholder lambda arguments, and the meaningless obfuscated variable in __setstate__ reduce clarity. The __getstate__ docstring also omits takes_field despite its inclusion in the returned state. Code length: Mostly concise, with some repetitive conditional logic, lengthy formatted strings, and two unnecessary assignments. Action granularity: Statements generally perform one action per line; multiline calls remain readable. Reading flow: Initialization, call formatting, and serialization follow a natural sequence, but dynamic __call__ assignment and annotation mutation require extra attention, while the unexplained final assignments interrupt otherwise coherent flow.
Run 3
Code Structure: Methods are logically grouped in a focused class, 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 converter behavior, but cryptic names such as ex, rt, and placeholder underscores require interpretation. The meaningless lI0O_247fe2c7 assignments obscure __setstate__, and __getstate__ documentation omits takes_field. Code length: Mostly proportional to functionality, with some verbose documentation, repeated formatting expressions, and unnecessary statements. Action granularity: Statements generally perform one action per line; lambdas remain reasonably simple. Reading flow: Initialization, call formatting, and serialization follow a natural sequence, but dynamically assigning __call__ and modifying its annotations add cognitive overhead. Overall, readable organization is weakened by isolated obfuscation and minor documentation inconsistencies.