attrs Documentation

You can execute code at specific stages of the attrs initialization process using these hooks:

• __attrs_pre_init__: Runs before attrs starts initializing. Primarily used to call super().__init__() when subclassing non-attrs classes.
• __attrs_post_init__: Runs after attrs has finished initializing the instance. Useful for deriving attributes or performing cross-attribute validation.

Note for @frozen classes: You cannot directly set attributes in __attrs_post_init__ on a frozen class. You must use object.__setattr__(self, "name", value) instead.

Order of Execution:

1. __attrs_pre_init__ (on current class)
2. For each attribute: default factory $\rightarrow$ converter $\rightarrow$ validators
3. __attrs_post_init__ (on current class)

# Post-init example
@define
class C:
    x: int
    y: int = field(init=False)
    def __attrs_post_init__(self):
        self.y = self.x + 1

# Post-init on a frozen class
@frozen
class Frozen:
    x: int
    y: int = field(init=False)
    def __attrs_post_init__(self):
        object.__setattr__(self, "y", self.x + 1)

There are three common ways to create attributes that depend on other attributes:

1. __attrs_post_init__ (Simplest): Set the derived attribute after initialization is complete.
2. Decorator-based default: Use @attribute_name.default to define a factory method that accesses other attributes.
3. Class method factory (Recommended): Use a @classmethod to handle complex setup. This is generally more testable and explicit.

Note: If using the decorator approach, the derived field must be included in the __init__ (e.g., field()) unless you specifically want it excluded.

# Approach 1: Post-init
@define
class APIClient:
    token: str
    client: WebClient = field(init=False)

    def __attrs_post_init__(self):
        self.client = WebClient(self.token)

# Approach 2: Decorator-based default
@define
class APIClient:
    token: str
    client: WebClient = field() 

    @client.default
    def _client_factory(self):
        return WebClient(self.token)

# Approach 3: Class method factory (Best practice)
@define
class APIClient:
    client: WebClient

    @classmethod
    def from_token(cls, token: str) -> "APIClient":
        return cls(client=WebClient(token))

If you wrap attrs decorators, Mypy's plugin may not recognize the resulting classes. To fix this, you can create a custom Mypy plugin that uses attr_attrib_makers, attr_class_makers, and attr_dataclass_makers to register your custom methods.

Note: This only tells Mypy that a class is an attrs class; it cannot inform Mypy about changes to defaults like eq or order.

from mypy.plugin import Plugin
from mypy.plugins.attrs import (
   attr_attrib_makers,
   attr_class_makers,
   attr_dataclass_makers,
)

# Register your custom methods
attr_dataclass_makers.add("my_module.method_looks_like_attr_dataclass")
attr_class_makers.add("my_module.method_looks_like_attr_s")
attr_attrib_makers.add("my_module.method_looks_like_attrib")

class MyPlugin(Plugin):
    pass

def plugin(version):
    return MyPlugin

Then add the plugin to your mypy.ini:

[mypy]
plugins=<path to file>

In attrs, slotted classes are created by passing slots=True to @attr.s. This option is enabled by default when using attrs.define(), attrs.mutable(), or attrs.frozen().

Slotted classes use less memory (on CPython) and are slightly faster than standard 'dict classes' because they use __slots__ instead of __dict__.

Important Gotchas:

• No extra attributes: You cannot set attributes that aren't defined in the class hierarchy's __slots__.
• Inheritance limits: You cannot inherit from more than one class that has __slots__ (results in TypeError: multiple bases have instance lay-out conflict).
• No monkeypatching: You cannot monkeypatch methods on slotted classes. If you need to monkeypatch for testing, you can subclass the slotted class as a dict class by setting slots=False.

from attr import define

@define
class Coordinates:
    x: int
    y: int

c = Coordinates(x=1, y=2)
# c.z = 3  # This would raise AttributeError