Reduce metaclass conflicts with less eager proclamation, automatic metaclass merges

[blhsing (Ben Hsing)]

@MegaIng

Here is also an IMO perfectly valid example where the current system breaks without using ABC (since that seems to be controversial):

@dataclass_transform()
class SlotDataclassMeta(type):
    def __new__(mcs, name, bases, attrs):
        # Don't automatically transform children further down the line.
        # This should probably be a smarter check.
        if any(is_dataclass(base) for base in bases):
            return super().__new__(mcs, name, bases, attrs)
        # Yes, this is too simplistic, but could be extended to work properly 
        attrs["__slots__"] = tuple(attrs.get('__annotations__', {}))
        cls = super().__new__(mcs, name, bases, attrs)
        cls = dataclass(cls)
        return cls


class Card(metaclass=SlotDataclassMeta):
    value: Literal[2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A']
    suite: Literal['heart', 'diamond', 'club', 'spade']

Here we define a new dataclass_transform that correctly sets the __slots__ of the class without creating a subclass. AFAIK, this isn’t possible without a metaclass since we need to take action before the class is created.

class PlayingCards(Card, Enum):
    TWO_OF_SPADES = 2, 'spade'
    TWO_OF_DIAMOND = 2, 'diamond'
    TWO_OF_CLUB = 2, 'club'
    TWO_OF_HEART = 2, 'heart'
    THREE_OF_SPADES = 3, 'spade'
    THREE_OF_DIAMOND = 3, 'diamond'
    THREE_OF_CLUB = 3, 'club'
    THREE_OF_HEART = 3, 'heart'
    # ...

Now if we try to use it like this, we run into a metaclass conflict. This last definition while using @dataclass for Card works, and infact has special support in the Enum library to created more structured enum values. It would be nice if this could work, no matter how our dataclass transform is implemented (be it decorator, base class or metaclass), but the current system heavily discourages metaclass usage because of these conflicts.

Good example, allthough to be fair, this can be implemented without a metaclass since we now have __init_subclass__:

from enum import Enum
from dataclasses import dataclass
from typing import dataclass_transform, Literal

@dataclass_transform()
class SlotDataclass:
    def __init_subclass__(cls):
        cls.__slots__ = tuple(vars(cls).get('__annotations__', {}))
        dataclass(cls)

class Card(SlotDataclass):
    value_: Literal[2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A']
    suite: Literal['heart', 'diamond', 'club', 'spade']

class PlayingCards(Card, Enum):
    TWO_OF_HEART = 2, 'heart'
    THREE_OF_SPADES = 3, 'spade'

so that:

print(list(PlayingCards))

outputs:

[PlayingCards(value_=2, suite='heart'), PlayingCards(value_=3, suite='spade')]

Demo here

Note that Enum members already have a value attribute so the value of a Card has to be named something else.