Having type hints changes inheritance on dataclass

[B-D-T]

Bug report

Bug description:

When declaring a subclass for a dataclass, including/omitting type hints change the behavior of inherited attributes. It seems that if the parent class has a type hint but the child class does not, the child class will not override the parent's attribute value.

Example for reproducing issue

from dataclasses import dataclass

@dataclass
class Field:
    name: str
    d_type: str = 'CustomType'

@dataclass
class FieldStr(Field):
    d_type: str = 'string'

@dataclass
class FieldStrNoHint(Field):
    d_type = 'string'

my_field = FieldStr('FieldWithString')
print(my_field.d_type) # expected: 'string', actual: 'string'

my_field = FieldStrNoHint('FieldWithStrNoHint')
print(my_field.d_type) # expected: 'string', actual: 'CustomType'

Expected Behavior

In both cases (FieldStr and FieldStrNoHint), the d_type attribute should return 'string'.

Actual Behavior

The child class with a type hint (FieldStr) correctly returns the value.

The child class without a type hint (FieldStrNoHint) returns the parent's value instead.

In this table, the result should always be the child's value, but if the parent has a hint and the child does not, the parent's value is used instead. The hint type doesn't matter (e.g., d_type: int on the parent still returns the same result).

Parent has hint	Child has hint	Result
Yes	Yes	Child's value
Yes	No	Parent's value
No	Yes	Child's value
No	No	Child's value

Other observations

If I change the type hint on the name attribute in the parent class, the behavior changes more dramatically. The child class appears to set the d_type attribute instead of the name when instantiating the object.

@dataclass
class Field:
    name = None # No hint on name
    d_type: str = 'CustomType'
# ... everything else is the same

my_field = FieldStr('FieldWithString')
print(my_field.d_type) # expected: 'string', actual: 'FieldWithString'

my_field = FieldStrNoHint('FieldWithStrNoHint')
print(my_field.d_type) # expected: 'string', actual: 'FieldWithStrNoHint'

Additional Information

Main environment

• Windows 11, 24H2
• Python version: 3.12.4

Replicated environment

• Google Colab
• Python version: 3.11.11

CPython versions tested on:

3.11, 3.12

Operating systems tested on:

Windows, Other

[ericvsmith]

Is there something that lead you to expect you could have a non-type-annotated member in a subclass that would act as if it were annotated? I think the dataclasses documentation is pretty clear that fields should be annotated. If a member is not annotated, dataclasses does not consider it a field, and ignores it. But the underlying class inheritance mechanism is still in effect, of course.

[B-D-T]

@ericvsmith asked,

Is there something that lead you to expect you could have a non-type-annotated member in a subclass that would act as if it were annotated?

My own ignorance, probably.

I had thought, mistakenly, that type hints do not affect runtime results. That is, I thought type hints are for IDEs and linters and wouldn't impact code execution for something as fundamental as class inheritance. But, as you note, the dataclass docs are clear in the description:

field: "a class variable that has a type annotation."

Summary

Just to make sure I understand things correctly, in my example, the child class's d_type is not a field because it doesn't have the type hint. It's not that python is preferencing the parent class's field - it's that python doesn't even consider the child class as having a field since there is no type annotation.

@dataclass
class Cparent:
    name: str
    d_type: str = 'CustomType' # Python sees this a field

@dataclass
class Cchild(Cparent):
    d_type = 'string' # Python doesn't consider this as a field

child = Cchild("child")
print(child.d_type) # returns "CustomType"

Similarly, the code below returns the child's attribute value because, even though there is no type annotation on the parent, NoneType is inferred because there is default value.

@dataclass
class Cparent:
    name: str
    d_type = None # No hint, but has a default value

@dataclass
class Cchild(Cparent):
    d_type = 'string' # No hint, but has a default value

child = Cchild("child")
print(child.d_type) # returns "string"

Close issue?

If my understanding is now correct, we can close this as a mistaken bug report. The behavior is a little surprising at first, but it seems to follow expected behavior.

I apologize for wasting time with the issue report. I appreciate the education and will know for future use of the dataclass decorator.

[ericvsmith]

@B-D-T : You didn't waste anyone's time! Thank you for taking the time and reporting what could have been a bug, I appreciate it.

I'll go ahead and close this.