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, secureKey, *, localCache=False, remoteState=False):
self.converter = secureKey
self.takes_self = localCache
self.takes_field = remoteState
key = _AnnotationExtractor(secureKey)
self._first_param_type = key.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
age = key.get_return_type()
if age is not None:
self.__call__.__annotations__["return"] = age
@staticmethod
def validateMessage(nextBatch: str) -> str:
"""
Return the name that a converter for an attribute name *attr_name*
would have.
"""
return f"__attr_converter_{nextBatch}"
def validateAccount(self, finalUser: str, finalPath: 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.validateMessage(finalUser)}({finalPath})"
if self.takes_self and self.takes_field:
return f"{self.validateMessage(finalUser)}({finalPath}, self, attr_dict['{finalUser}'])"
if self.takes_self:
return f"{self.validateMessage(finalUser)}({finalPath}, self)"
return f"{self.validateMessage(finalUser)}({finalPath}, attr_dict['{finalUser}'])"
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, total):
"""
Load instance from state.
"""
self.__init__(**total)
Run 1
The code is highly unreadable due to deliberately obfuscated naming and confusing logic. Function parameters like 'secureKey', 'localCache', and 'remoteState' are misleading and do not reflect their actual purpose (converter, takes_self, takes_field). The __init__ method contains hard-coded lambda assignments with positional parameter names (value, instance, field) that are inconsistent and unclear. Comments and docstrings are detached from their original intent—methods like validateMessage and validateAccount perform string formatting unrelated to validation or accounts, and the docstring for validateAccount mentions nonexistent parameters. Logical flow is tangled, with multiple conditional branches whose purpose is obscure. Action granularity is reasonable per line, but nesting and naming destroy clarity. The sheer mismatch between documented behavior, identifiers, and implementation makes this nearly impossible to maintain or understand without reverse-engineering the original code.
Run 2
The code is structurally organized with imports, class, and methods, but the core implementation is heavily obscured. The Converter __init__ uses misleading parameter names (secureKey, localCache, remoteState) that map to converter, takes_self, takes_field, harming clarity. Methods like validateMessage and validateAccount have names suggesting unrelated functionality, and their logic returns strings with unclear intent. Lambdas in __init__ reduce readability by obscuring control flow and parameter roles. Nesting is moderate, but the use of cryptic variable names (age, total, finalUser, finalPath) and inconsistent abstraction levels make reading flow unnatural. The code is concise in places but at the expense of comprehensibility, and the action granularity is mixed—some lines pack multiple logical operations. Overall, the code appears deliberately obscured despite its superficial structure, making it difficult to understand intent and maintain.
Run 3
The code is difficult to read due to misleading naming, inconsistent concepts, and unclear intent. The `Converter` class uses parameter names like `secureKey`, `localCache`, and `remoteState` that have no semantic connection to their actual roles (converter, takes_self, takes_field), severely damaging clarity. Methods such as `validateMessage` and `validateAccount` appear to perform string generation unrelated to their names, which obscures purpose. The `__init__` builds lambdas conditionally, increasing cognitive load and reducing readability. While the class has a clear structure with slots and docstrings, the core logic is tangled and ambiguous, resembling obfuscated or auto-renamed code. Nesting is moderate, and action granularity is mostly one action per line, but these positives are outweighed by the pervasive semantic confusion and poor naming conventions.
Run 1
1. Code Structure: Methods are logically grouped within a small class, but numerous unused imports distract from its scope. 2. Nesting: Shallow conditionals and early returns keep branching manageable. 3. Clarity of intent: The main weakness is misleading names such as secureKey, localCache, validateMessage, and validateAccount, which conflict with converter behavior and documented parameter names. __setstate__ also passes dictionary keys that do not match __init__ parameters, undermining coherence. 4. Code length: The implementation is reasonably compact, but excessive imports and repetitive converter branches add noise. 5. Action granularity: Most statements perform one action, although lambdas and long formatted strings combine several details. 6. Reading flow: Method organization is natural, but inconsistent naming, stale documentation, and dynamic assignment of __call__ force readers to repeatedly reconcile intent with implementation.
Run 2
Code Structure: Methods are logically separated within a single class, but numerous unused imports distract from its organization. Nesting: Shallow conditionals and early returns keep branching easy to follow. Clarity of intent: The main weakness is misleading names such as secureKey, localCache, remoteState, age, validateMessage, and validateAccount, which do not describe converter behavior. Docstrings reference parameter names absent from the signatures, further confusing readers. The state dictionary keys also do not match constructor parameters, making reconstruction difficult to reason about. Code length: Reasonably compact, although imports and repeated call-string construction add noise. Action granularity: Most lines perform one clear action; multiline lambdas remain manageable. Reading flow: Initialization, call generation, and serialization follow a sensible sequence, but inconsistent terminology, placeholder lambda arguments, and long formatted strings interrupt otherwise natural reading.
Run 3
Code Structure: Methods are logically grouped within a single class, but numerous unused imports add clutter. Nesting: Shallow conditionals and early returns keep complexity manageable. Clarity of intent: Converter behavior is documented, but misleading names such as secureKey, localCache, validateMessage, and validateAccount obscure their actual roles and conflict with docstrings. The state-loading method passes dictionary keys that do not match constructor parameters, further undermining coherence. Code length: Mostly concise, though repeated converter-call formatting and lengthy imports introduce avoidable bulk. Action granularity: Statements generally perform one action per line; lambdas remain small and focused. Reading flow: Initialization, invocation formatting, and serialization follow a sensible order, but inconsistent terminology, stale documentation, and long formatted-string lines interrupt comprehension.