New check: suggest `dataclass` when `__init__` only assigns instance variables

[nickdrozd]

Current problem

It's very common to have __init__ methods that only assign instance variables:

class Thing:
    def __init__(self, this, that, the_third):
        self.this = this
        self.that = that
        self.the_third = the_third

Desired solution

It would be less verbose to declare such a class as a dataclass:

from dataclasses import dataclass

@dataclass
class Thing:
    this: int
    that: str
    the_third: str

This way, the instance variables are declared only once, rather than twice (field and argument). Additionally, the dataclass version requires type annotations, which are generally a good thing.

A new check could be added that detects __init__ methods that only assign instance variables and suggests using a dataclass instead. IMO this would be in keeping with existing Pylint checks that suggest using higher-level language features (for example, suggesting enumerate).

Additional context

No response

[Pierre-Sassoulas]

When should it raises ? If there's only the __init__ in the class ? If no function defined in the dataclass are defined ? All the time ?

[DudeNr33]

The Python standard library alone has several alternatives for this case, depending on the specific use case:

• decorating with @dataclass
• subclassing typing.NamedTuple
• or a bit more old-school, using collections.namedtuple

Third party libraries like attrs or pydantic also solve similar problems.

I like the idea, but would recommend to

• only raise this message on "bare" classes that do not inherit from anything and are not decorated - otherwise there could be a lot of complaints about false positives
• don't specifically suggest dataclass as solution, as this is a matter of the specific use case / requirements and taste

[nickdrozd]

Good questions. I'm specifically thinking of the case of a class that has methods defined in addition to the __init__. For such classes, dataclass is more suitable.

So this check would look for classes with:

1. An __init__ that only assigns instance variables;
2. Some other methods;
3. No inheritance.

Then a suggestion to use dataclass could be emitted.

[DanielNoord]

I think this is very specific to the codebase and you would need a --suggestion-for-simple-classes option to suggest the correct solution the user wants. It feels like this is better served by a separate extension outside of the main codebase which can focus on the specific needs of individual users.

[nickdrozd]

Argument for a more radical approach: https://blog.glyph.im/2023/02/data-classification.html