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 demonstrates excellent readability through clear structure and organization. Imports are logically grouped with a mix of standard library, third-party, and local modules. The Factory class has a well-documented purpose with a clear docstring explaining its usage and parameters. Each method has a single, focused responsibility - __init__, __getstate__, and __setstate__ each perform one clear action. The code uses modern Python features appropriately (__slots__, zip with strict=True, type hints) without sacrificing clarity. Naming conventions are consistent and descriptive. The use of __slots__ reduces memory overhead while the concise implementation avoids unnecessary verbosity. Comments are minimal but meaningful, with version annotations where relevant. The only minor deduction is that some context about the broader attrs library would help understand this class's role in the larger system, but within its scope, it's exceptionally clear and well-structured.
Run 2
The code is highly readable. It has a clear class definition with a well-documented docstring explaining purpose and parameters. Imports are organized logically from standard library to local modules. The Factory class uses __slots__ for efficiency and implements pickle support cleanly. The constructor is concise and clear, with default values. The __getstate__/__setstate__ methods are flat, use tuple/generator and zip with strict=True, making intent obvious. Minor deductions could be for lack of type hints in method signatures and slight reliance on internal dunder methods that may not be immediately clear to all readers, but these are acceptable given the library context and Python idiom. Overall structure, granularity, and flow are excellent.
Run 3
The code demonstrates strong structural organization with clear imports, a single well-defined class, and appropriate use of slots. Nesting is minimal and action granularity is clear. The Factory class has an easily understood purpose and the docstrings explain the intent well. Reading flow is natural, with the class definition following imports and the methods following the constructor. Minor deductions: a module-level docstring is missing, and the constructor parameters lack type hints, which would improve clarity. Overall, this is highly readable code.
Run 1
Code Structure: Imports and a single focused 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 descriptive names make initialization and serialization understandable; the pickle method docstrings could explain the state format more precisely. Code length: The implementation is concise, though the import block is disproportionately large for the shown class. Action granularity: Each statement performs one clear action, with a straightforward generator expression for collecting state. Reading flow: The progression from documentation and slots to initialization and pickle support is natural. Minor spacing improvements between import groups and before the class would improve visual separation.
Run 2
Code Structure: The class is logically organized, with initialization followed by serialization methods, though the many unused imports clutter this excerpt. Nesting: Methods are flat, with only a simple loop in __setstate__. Clarity of intent: Descriptive names and a detailed class docstring clearly explain factory behavior; the pickle method docstrings are less precise. Code length: The implementation is concise, although the import block and documentation are substantial relative to the executable code. Action granularity: Each statement performs one clear action, and the generator expression remains easy to understand. Reading flow: Methods follow a natural progression, but the lack of blank lines between import groups and before the class slightly weakens visual organization.
Run 3
Code Structure: The class is logically organized into documentation, slots, initialization, and serialization methods, although many imports are unused in the shown snippet. Nesting: Methods are flat, with only a single shallow loop. Clarity of intent: Descriptive names and a detailed class docstring clearly explain the factory and takes_self behavior; the pickle method docstrings are less specific. Code length: The implementation is concise, though the import block is disproportionately large for this excerpt. Action granularity: Each statement performs one clear action, and the generator expression remains straightforward. Reading flow: Methods follow a natural order, and consistent formatting makes the class easy to scan; stronger separation between import groups would slightly improve readability.