CODEWITHSUNDEEP
pythonpython-3.xpython-dataclasses
Or B
Or B

Reputation: 1803

Check if a class is a dataclass in Python

How can I check if a class is a dataclass in Python?

I found out that I can check the existance of __dataclass_fields__ and __dataclass_params__ attributes, but I'd love to find a more elegant way to do this.

I'd expect using something like inspect.isclass function. Maybe something like inspect.isdataclass, for example.

Does Python have something like that?

Thanks.

Upvotes: 39

Views: 28644

Answers (3)

Albert
Albert

Reputation: 626

To verify whether a class is defined with @dataclass, testing for the __dataclass_* attributes (with dataclass.isdataclass()) will not do. As a (normal) subclass will inherit those field(s) ...

This can be an issue with mutation-testing (see for example "mutmut"). It will report deleting @dataclass is not seen in a test. That is annoying (mostly when subclassing, without adding new annotations)

As a workaround: we can check for an own __init__ – as @dataclass will typically generate one.

def isDataClass(cls):
    assert dataclasses.is_dataclass(cls) # This will also pass when cls inherits from a dataclass
    my_init = getattr(cls, '__init__')
    inherited_init = getattr(cls.mro()[1], '__init__')
    assert my_init is not inherited_init, f"Probably you subclasses a dataclass, but forgot @dataclass for {cls}"

Not perfect, but it does help.

Upvotes: 0

imposeren
imposeren

Reputation: 4392

Docs

import dataclasses
dataclasses.is_dataclass(something)

As mentioned by @Arne internally it simply checks hasattr(something, '__dataclass_fields__'), but I'd recommend to not rely on this attribute and directly use is_dataclass.

Why you should not rely on __dataclass_fields__:

  • This attribute is not a public API: it's not mentioned anywhere in the docs.
  • It's an implementation detail, and so it's not guaranteed to work in other python implementations. But besides cPython nothing seems to support Python3.7 yet (as of May 2019). At least Jython, IronPython and PyPy do not support it, so it's hard to tell if they will be using the same attribute or not

Everything else including differences between checking for dataclass type and dataclass instance is in the docs of is_dataclass method:

# (from the docs)
def is_dataclass_instance(obj):
    return is_dataclass(obj) and not isinstance(obj, type)

Upvotes: 62

amanb
amanb

Reputation: 5463

Extending upon the answer above, the following illustrates the usage of is_dataclass():

Remember: The parameter passed to is_dataclass() can be a dataclass or an instance of the dataclass, to return True from the method call.

In [1]: from dataclasses import dataclass

In [2]: @dataclass
   ...: class Bio:
   ...:     name: str
   ...:     age: int
   ...:     height: float
   ...:

In [3]: from dataclasses import is_dataclass

In [4]: is_dataclass(Bio)
Out[4]: True

In [5]: b = Bio('John', 25, 6.5)

In [6]: is_dataclass(b)
Out[6]: True

To check whether, b is an instance of the dataclass and not a dataclass itself:

In [7]: is_dataclass(b) and not isinstance(b, type)
Out[7]: True

Bio is a dataclass, so the following expression evaluates to False:

In [8]: is_dataclass(Bio) and not isinstance(Bio, type)
Out[8]: False

Lets check for a regular class:

In [9]: class Car:
   ...:     def __init__(self, name, color):
   ...:         self.name = name
   ...:         self.color = color
   ...:

We know Car is not a dataclass:

In [10]: is_dataclass(Car)
Out[10]: False

In [11]: c = Car('Mustang', 'Blue')

Neither an instance of Car is a dataclass instance:

In [12]: is_dataclass(c)
Out[12]: False

Upvotes: 7

Related Questions