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 well-structured and readable. It uses clear class and method definitions, type hints, and descriptive docstrings. The Factory class is flat with no unnecessary nesting, and each method performs a single logical action. Naming is consistent and intent is clear, especially with docstrings explaining *takes_self* and pickle compatibility. Imports are organized, though some unused imports (e.g., contextlib, itertools, sys) slightly reduce clarity. The __getstate__ and __setstate__ methods are concise but use zip with strict=True, which is fine for supported Python versions. Overall, the code is highly readable with minor room for improvement in import tidiness.
Run 3
The code is generally well-structured and readable. It has clear imports, a focused class with a single responsibility, and good documentation. The Factory class is flat with no nested logic, and methods are concise with one action per line. The reading flow is natural, with the class docstring clearly explaining purpose and parameters. Minor deductions: several unused imports reduce clarity, and the pickle support methods, while simple, add slight noise to an otherwise clean class. The explicit use of __slots__ is good practice but may not be immediately obvious to all readers. Overall, the code is maintainable and easy to follow.
Run 1
Code Structure: Imports and a focused class are logically organized, although many imports are unused in this excerpt. Nesting: Methods are flat, with only one shallow loop. Clarity of intent: Descriptive names and a detailed class docstring clearly explain the factory behavior; pickle methods are understandable, though their docstrings are informal. Code length: The implementation is concise, but the extensive import block and documentation outweigh the small amount of executable code. Action granularity: Each statement performs one clear action; the generator expression is compact without being difficult to follow. Reading flow: The progression from initialization to serialization and restoration is natural, with consistent formatting and minimal distractions.
Run 2
Code Structure: The class is logically organized, with configuration, initialization, and serialization methods clearly separated. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: Descriptive names and a detailed class docstring explain the factory's purpose; the serialization docstrings are less precise. Code length: The implementation is concise, although the many imports unused in this excerpt add visual clutter. Action granularity: Each statement performs one clear action, and the generator expression remains readable. Reading flow: Methods follow a natural order, but limited spacing between import groups and before the class slightly weakens presentation.
Run 3
Code Structure: Imports and a single focused class are logically organized, though many imports are unused in this snippet. Nesting: Methods are flat, with only one simple loop. Clarity of intent: Descriptive names and a detailed class docstring clearly explain factory behavior; serialization methods are straightforward, although their docstrings could describe state handling more precisely. Code length: The implementation is concise, with documentation accounting for most of its length. Action granularity: Each statement performs one clear action; the generator expression remains easy to follow. Reading flow: The class progresses naturally from documentation and slots to initialization and serialization. Minor spacing improvements between import groups and before the class would improve visual organization.