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 Factory:
"""
Stores a factory callable.
If passed as the default value to `attrs.field`, the factory is used to
generate a new value.
Args:
factory (typing.Callable):
A callable that takes either none or exactly one mandatory
positional argument depending on *takes_self*.
takes_self (bool):
Pass the partially initialized instance that is being initialized
as a positional argument.
.. versionadded:: 17.1.0 *takes_self*
"""
__slots__ = ("factory", "takes_self")
def __init__(self, fac, takes=False):
self.factory = fac
self.takes_self = takes
def __getstate__(self):
"""
Play nice with pickle.
"""
return tuple(getattr(self, nam) for nam in self.__slots__)
def __setstate__(self, sta):
"""
Play nice with pickle.
"""
for nam2, val in zip(self.__slots__, sta, strict=True):
setattr(self, nam2, val)
Run 1
The code is well-structured and highly readable. The Factory class is logically organized with clear separation of attributes, initialization, and serialization methods. Docstrings succinctly explain purpose and arguments. Nesting is minimal — the __getstate__ and __setstate__ methods use flat comprehensions and straightforward loops, avoiding deep indentation. Intent is explicit: the class name, parameter names, and version notes make its role in attrs clear. Code length is appropriate, with no unnecessary boilerplate. Action granularity is good — each line performs one logical operation, such as assigning attributes or iterating with zip. Reading flow is natural: imports, class definition, __slots__, constructor, then pickle support methods in a logical sequence. The use of __slots__ and strict=True in zip show modern, intentional Python. Overall, the code is concise, self-documenting, and maintainable.
Run 2
The code is well-structured: imports are clearly organized (stdlib, third-party, local) and the class has a clear single purpose with good docstrings. Nesting is minimal — only two flat loops in __getstate__/__setstate__, with no deep conditional branching. Intent is clear: the Factory class stores a callable and handles pickling. Code length is appropriate; no unnecessary verbosity or redundancy. Action granularity is reasonable: __getstate__ packs a tuple comprehension into one line but remains readable; __setstate__ uses one action per line with a zip loop. Reading flow is natural: class definition, docstring, slots, init, then pickle methods. Minor deductions: the __getstate__ comprehension slightly reduces readability; parameter names (fac, sta, nam, nam2) are terse but still understandable in context. Overall, concise and maintainable code with clean structure.
Run 3
The code is highly readable. It has a clear structure with imports organized logically, a single class with a well-documented purpose, and methods that follow a consistent pattern. Nesting is minimal, and each action is generally on its own line. The class docstring clearly explains parameters and version notes. The only slight deductions are due to abbreviated parameter names like 'fac' and 'nam2' which are less descriptive than the rest of the code, and the use of `__slots__` with string tuples can be slightly opaque to beginners. Overall, the intent is unambiguous and the reading flow is natural.
Run 1
Code Structure: Imports and a single class are logically organized, although many imports are unused in this snippet. Nesting: Methods are flat, with only one simple loop. Clarity of intent: The class docstring clearly explains factory behavior, and standard serialization method names convey purpose; abbreviated parameters and variables such as fac, takes, sta, nam, and nam2 reduce clarity. Code length: The implementation is concise, though the import block is disproportionately long relative to the class. Action granularity: Statements generally perform one action per line; the generator expression is compact and understandable. Reading flow: The progression from documentation and slots to initialization and serialization is natural. Minor distractions include the mismatch between documented argument names and constructor parameters, plus limited spacing between imports and the class.
Run 2
Code Structure: The class is logically organized into initialization and serialization methods, although numerous imports are unused in this snippet. Nesting: Minimal nesting makes the methods easy to follow. Clarity of intent: The class docstring clearly explains its purpose, but abbreviated parameter and variable names (fac, takes, sta, nam, nam2) reduce clarity and differ from documented argument names. Code length: The implementation is concise; documentation is longer but useful. Action granularity: Statements generally perform one action per line, with a straightforward generator expression for serialization. Reading flow: Methods follow a natural order, though the large import block and inconsistent naming slightly interrupt readability.
Run 3
Code Structure: The class is logically organized into initialization and serialization methods, although many imports are unused in this snippet. Nesting: The code is flat, with only a simple loop in __setstate__. Clarity of intent: The class docstring clearly explains its purpose, but abbreviated parameter and variable names such as fac, sta, nam, and nam2 reduce clarity; the documented argument names also differ from the constructor signature. Code length: The implementation is concise, though the import block is disproportionately large for the shown functionality. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural order, and formatting is consistent, but the extensive imports and inconsistent naming slightly interrupt readability.