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, factory, takes_self=False):
self.factory = factory
self.takes_self = takes_self
def __getstate__(self):
"""
Play nice with pickle.
"""
return tuple(getattr(self, name) for name in self.__slots__)
def __setstate__(self, state):
"""
Play nice with pickle.
"""
for name, value in zip(self.__slots__, state, strict=True):
setattr(self, name, value)
Run 1
The code is well-structured with clear imports, docstrings, and class organization. The Factory class has a single responsibility and uses __slots__ appropriately. Nested logic is minimal, with only a single loop in __setstate__ using zip with strict=True for safety. Intent is clearly conveyed through descriptive naming and comprehensive docstrings explaining purpose, arguments, and version additions. Code length is concise without being terse; each method contains only essential logic. Action granularity is appropriate - each line performs one clear operation, like tuple unpacking in __getstate__ or the zip iteration in __setstate__. Reading flow is natural, moving from class documentation through constructor to serialization methods. Minor improvements could include type hints on method parameters and more explicit error handling in __getstate__ if attributes are missing, but overall the code is highly readable and maintainable.
Run 2
The code is generally clear and well-organized. It uses straightforward imports, a simple class with `__slots__`, and concise methods. The `Factory` class has a clear purpose, and the docstrings explain its behavior and parameters. The pickle support methods are brief and logical. Minor deductions: the `zip` call with `strict=True` assumes Python 3.10+, which may not be obvious to all readers; the class name is generic but acceptable in context; and a few lines (like `return tuple(getattr(self, name) for name in self.__slots__)`) pack multiple logical actions, slightly reducing action granularity. Overall, the code is readable and maintainable.
Run 3
The code is well-structured with clear imports, a focused single class, and descriptive docstrings. Nesting is flat, intent is clear, and action granularity is appropriate. The Factory class has a single responsibility, and methods are concise, though __getstate__ and __setstate__ could be slightly simplified. Overall readable and maintainable.
Run 1
Code Structure: The class is logically organized into documentation, slots, initialization, and serialization methods, although the extensive imports appear unused in this snippet. Nesting: Methods are flat, with only a simple loop in __setstate__. Clarity of intent: Descriptive names and a detailed class docstring clearly explain the factory's purpose; the serialization docstrings are less precise. Code length: The implementation is concise, though the import block and documentation dominate this small excerpt. Action granularity: Each statement performs one clear action, with a straightforward generator expression for collecting state. Reading flow: The progression from initialization to saving and restoring state is natural. Minor spacing improvements between imports and the class would further improve readability.
Run 2
Code Structure: Imports and a single, cohesive class are logically organized, although many imports are unused in this excerpt. Nesting: Methods are flat, with only one simple loop. Clarity of intent: Descriptive names and a detailed class docstring clearly explain the factory and takes_self behavior; serialization docstrings are less specific. Code length: The implementation is concise, though the extensive imports and documentation outweigh the small amount of executable code. Action granularity: Statements generally perform one action per line; the generator expression remains straightforward. Reading flow: The progression from documentation to slots, initialization, and serialization is natural. Additional blank lines between import groups and before the class would improve visual separation.
Run 3
Code Structure: The class is logically organized into initialization and serialization methods, although many imports are unused in this snippet. Nesting: Methods are flat, with only a simple loop in __setstate__. Clarity of intent: Descriptive names and a detailed class docstring clearly explain the factory's purpose; serialization docstrings are less specific. Code length: The implementation is concise, but the extensive imports and documentation add overhead relative to its size. Action granularity: Each statement performs a single clear action. Reading flow: The progression from class documentation to initialization and state handling is natural, though the import-heavy opening and limited spacing between sections slightly reduce readability.