how to make abstract class that forces implementors to be dataclass

I have an abstract class, which for any T that implements it, lets you convert a List[T] into a csv file string. It looks like this:

from abc import ABC, abstractmethod
from dataclasses import dataclass, fields
from typing import List, Type, TypeVar
T = TypeVar('T')

class CsvableDataclass(ABC):
    @classmethod
    def to_csv_header(cls) -> str:
        return ','.join(f.name for f in fields(cls))
    def to_csv_row(self) -> str:
        return ','.join(self.format_field(f.name) for f in fields(self))
    
    @abstractmethod
    def format_field(self, field_name: str) -> str:
        pass
    
    # actually make a csv string using the methods above
    @staticmethod
    def to_csv_str(t: Type[T], data: List[T]):
        return '\n'.join([t.to_csv_header()] + [r.to_csv_row() for r in data])

@dataclass
class A(CsvableDataclass):
    x: int
    y: int
    def format_field(self, field_name: str) -> str:
        if field_name == 'x': return str(self.x)
        if field_name == 'y': return str(self.y)
        raise Exception(f"invalid field_name: {field_name}")

CsvableDataclass.to_csv_str(A, [A(1,2),A(3,4)])
# "x,y\n1,2\n3,4"

I'm using fields() from the dataclasses module to get the fields to make the header row and all other rows of the csv. fields() only works on instances or classes that are @dataclass.

How do I enforce (in the type annotations) that a class that extends CsvableDataclass must be a @dataclass?

That is tricky -
Because there is not one "thing" that distinguises dataclasses after they exist.

That is of the reasons @dataclass is a decorator and not a base class: it instruments the class where it is applied, but those classes can be anything.

Forget about typing altogether: there is nothing special in typing as far as dataclasses are concerned, except that they recognize the @dataclass decorator (and can learn about other similar decorators), so that the type checking tools know the final resulting class is "more than meets the eye", and has methods and capabilities that are not explicit in the source code.

For your purposes, of being able to re-use dataclasses.fields - what may work is to implement in your class itself a mechanism that will make all child classes dataclasses automatically.

But then, it might conflict if users of your class would use
@dataclass themselves (and in particular, with different arguments)

Otherwise, add an __init_subclass__ method to your class that goes along this:

from dataclasses import dataclass, fields

...
class CVSAbleDataClass(...):
    ...

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        cls = dataclass(cls)
    ...

(and btw, in your next questions, do include the import statements along with your snippet: they are part of the code and provide valuable context for answering) 

</details>