chore: Add DTypeClass to improve DType.__repr__ and simplify __slots__

[FBruzzesi]

What type of PR is this? (check all applicable)

• 💾 Refactor
• ✨ Feature
• 🐛 Bug Fix
• 🔧 Optimization
• 📝 Documentation
• ✅ Test
• 🐳 Other

Related issues

• Closes Improve DType.__repr__ and simplify __slots__ maintenance via metaclasses #3212

Checklist

• Code follows style guide (ruff)
• Tests added
• Documented the changes

If you have comments or can explain your changes, please do so below

[dangotbanned]

I pushed this (failing) test as I've been thinking about if we want to distinguish here?

[FBruzzesi]

I think it could make sense to distinguish between the two...buuuut do we have a valid proposal? There is none I can think of that I really like to be honest with you 🤔

[dangotbanned]

Detour

I experimented with this a little bit in #2571

narwhals/narwhals/_plan/expr.py

Lines 56 to 61 in 1ab1599

	class Expr:
	_ir: ir.ExprIR
	_version: ClassVar[Version] = Version.MAIN
	def __repr__(self) -> str:
	return f"nw._plan.Expr({self.version.name.lower()}):\n{self._ir!r}"

Which looks like:

import narwhals._plan as nwp

nwp.col("a").drop_nulls().alias("b")

nw._plan.Expr(main):
col('a').drop_nulls().alias('b')

But I'd forgotten I did that, since _repr_html_ overrides that:

[dangotbanned]

Proposal

But since we only have 3x DTypes, maybe something like:

import narwhals as nw
from narwhals.dtypes import DType
from narwhals._utils import Version


def repr_dtype_class(dtype: type[DType], version: Version) -> str:
    v = f"[{version.name.lower()}]" if version is not Version.MAIN else ""
    return f"{dtype.__name__}{v}"


repr_dtype_class(nw.Datetime, Version.MAIN), repr_dtype_class(nw.Datetime, Version.V1)

('Datetime', 'Datetime[v1]')

Note

I'm open to changes, this was just the first idea I thought of

[FBruzzesi]

('Datetime', 'Datetime[v1]')

I kinda like this - Should this differentiation apply only to new types or all of them when calling from a non-main version?

@MarcoGorelli gentle summoning to get your thoughts as well here

[dangotbanned]

Should this differentiation apply only to new types or all of them when calling from a non-main version?

Ah yeah that is a quirk I suppose

I used Version in (#3213 (comment)) because it was how I'd done it before, but I suppose we haven't defined it on DTypes.

And everything besides these guys are just re-exports of main:

from narwhals.stable import v1

v1.Datetime
Datetime[v1]

v1.Duration
Duration[v1]

v1.Enum
Enum[v1]

I think the most important part is being able to tell the difference between Enum and v1.Enum, since only one has a constructor.

For everything else, I can see the argument for consistency - but we would be adding noise for things like:

import narwhals as nw
from narwhals.stable import v2

nw.List
List

v1.List
List[v1]

v2.List
List[v2]

Or if we extended the idea to DType instances (totally optional):

nw.List(nw.String)
List(String)

v1.List(v1.String)
List[v1](String[v1])

v2.List(v2.String)
List[v2](String[v2])

[dangotbanned]

Thanks @FBruzzesi, I've been wanting this for a while 🥳

(#3213 (comment)) isn't blocking for me