support field_specifiers in dataclass_transform

[carljm]

This is important, because it is used by two of the most popular clients of dataclass_transform, attrs and pydantic.

[carljm]

@PrettyWood is planning to look into this

[carljm]

For some reason GitHub won't let me actually assign the issue to @PrettyWood, so I'm assigning it to myself, just to mark that it isn't unowned

[AlexWaygood]

For some reason GitHub won't let me actually assign the issue to @PrettyWood, so I'm assigning it to myself, just to mark that it isn't unowned

for people outside the organisation, they need to have commented on the issue before GitHub will let you assign them to the issue

[carljm]

for people outside the organisation, they need to have commented on the issue before GitHub will let you assign them to the issue

I feel like every month or so I learn this again and then forget it again

[PrettyWood]

I'm actually working on it directly in astral-sh/ruff#19825.

It's trickier than I thought because when I first started, I thought field_specifiers was the only missing piece and I went with

• parse `@dataclass_transform(field_specifiers=(Field, ...))
• store the field specifiers
• detect calls to those field specifiers
• apply dataclass-like validation (via FieldInstance...)

The assumption was that @dataclass_transform itself was already fully supported but it's not. I'm working on making it understood for attrs and pydantic
I'll keep you posted

[carljm]

The assumption was that @dataclass_transform itself was already fully supported but it's not. I'm working on making it understood for attrs and pydantic

Interesting, I thought it was supported enough for your plan in the above bullet points to be sufficient. What else is missing? It seems like we support it enough for kw_only_default to be respected.

[PrettyWood]

@carljm metaclasses decorated with @dataclass_transform(kw_only_default=True) did not forward the information to the applied classes, which is what pydantic uses
But it's ok it's now fixed

Here is a summary of current behaviour for dataclass_transform, attrs and pydantic

import attrs
import pydantic
from typing import dataclass_transform, reveal_type
from dataclasses import dataclass


@dataclass(kw_only=True)
class DataclassUser:
    name: str
    age: int


reveal_type(DataclassUser.__init__)
# # `(self: DataclassUser, *, name: str, age: int) -> None` 🟢 


@dataclass_transform(kw_only_default=True)
def model(cls):
    return cls


@model
class CustomUser:
    name: str
    age: int


reveal_type(CustomUser.__init__)
# `(self: CustomUser, *, name: str, age: int) -> None` 🟢


@dataclass_transform(kw_only_default=True)
class ModelMeta(type):
    pass


class CustomModel(metaclass=ModelMeta):
    def __init__(self, **data):
        for k, v in data.items():
            setattr(self, k, v)


class CustomMetaclassUser(CustomModel):
    name: str
    age: int


reveal_type(CustomMetaclassUser.__init__)
# `(self: CustomMetaclassUser, name: str, age: int) -> None` 🟠 (`kw_only_default` not recognised)

@attrs.define(kw_only=True)
class AttrsUser:
    name: str
    age: int


reveal_type(AttrsUser.__init__)
# `(self: AttrsUser, name: str, age: int) -> None` 🟠
# (`kw_only_default` not recognised but expected because stub file doesn't add `kw_only_default` in `@dataclass_transform`)


class PydanticUser(pydantic.BaseModel):
    name: str
    age: int


reveal_type(PydanticUser.__init__)
# `(self: PydanticUser, __pydantic_extra__: @Todo(unknown type subscript) | None = Any, __pydantic_fields_set__: set[str] = Any, __pydantic_private__: @Todo(unknown type subscript) | None = Any, name: str, age: int) -> None` 🔴
# `kw_only_default` not recognised because Pydantic uses metaclass
# extra fields in signature that will be removed when `field_specifiers` are implemented)