`too-many-positional-arguments`: dataclasses?

[decorator-factory]

Summary

too-many-positional-arguments (PLR0917)

from dataclasses import dataclass

@dataclass
class Thing:
    foo: float
    bar: float
    baz: float
    width: float
    height: float
    is_fizz: bool
    is_buzz: bool
    is_fizzbuzz: bool

This implicilty creates an __init__ with 8 positional arguments, so a caller is allowed to do Thing(1, 2, 3, 4, 5, True, True, True) which doesn't look very clear. However, too-many-positional-arguments does not catch this.

I'm not sure how to best detect this, since there's more than just built-in dataclasses. (hardcode dataclasses, msgspec, pydantic?) (if we had type information, we could check if a "dataclass transform" is used)

[ntBre]

This seems like maybe a better fit for a separate rule to me, like too-many-dataclass-fields, although I can also see why it could fit into the same rule. We have some existing support for other types of dataclasses that we could reuse from other rules at least.

[decorator-factory]

For context, dataclass fields can be keyword-only, e.g.:

@dataclass(kw_only=True)
class Thing:
    foo: float
    bar: float
    is_fizzbuzz: bool

# only some of them

@dataclass(kw_only=True)
class Thing:
    name:
    _: dataclasses.KW_ONLY
    foo: float
    bar: float
    is_fizzbuzz: bool

I do agree that a separate rule probably makes more sense. Maybe some people want to limit the number of attributes in a dataclass in general, and then limiting the number of ones that are positional in the __init__ makes sense as a setting for that.

[clueless-skywatcher]

Hello! It's my first time here and I have been making a basic implementation of a Rust linter for python (for learning purposes) inspired by Ruff. I believe this issue can be a good first issue for me to contribute, so I'd like to take this up.

[clueless-skywatcher]

In my opinion, we can either make this rule, OR enforce that a dataclass is kw_only above a threshold of fields.