PyCharm unable to identify inherited class' attributes - python-3.x

Question

There's a base data class as follows:
class BaseClass:
def __init__(self, attribute_1: Any):
self.attribute_1 = attribute_1
There's an inherited data class using the above class as base class:
class DataClass(BaseClass):
def __init__(self, attribute_1: Any, attribute_2: Dict[str, str], attribute_3: List[str]):
super().__init__(attribute_1)
self.attribute_2 = attribute_2
self.attribute_3 = attribute_3
There's another BaseClass which expects an instance of BaseClass to work as follows:
class BaseActionClass:
def __init__(self, attribute_a1: BaseClass, attribute_a2: Dict[str, str])
self.attribute_a1 = attribute_a1
self.attribute_a2 = attribute_a2
def do_action_one(self):
pass
def do_action_two(self):
pass
There's an ActionClass which uses this BaseActionClass to perform some actions:
class ActionClass(BaseActionClass):
def __init__(self, attribute_a1: DataClass, attribute_a2: Dict[str, str]):
super().__init__(attribute_a1, attribute_a2)
def do_action_one(self):
do_statement_1
x = self.attribute_a1.attribute_1
y = self.attribute_a1.attribute_2
def do_action_two(self):
do_something
In ActionClass.do_action_one, when writing y = self.attribute_a1.attribute_2, PyCharm shows a typing error of Unresolved attribute reference 'attribute_2' for class 'BaseClass'. How to resolve this typing error which is shown by the IDE, and why would this happen since DataClass is already inheriting from BaseClass?

Answer 1

The problem now is that ActionClass.attribute_a1 is still BaseClass, because its base was declared so. It is absolutely fine, because in ActionClass you do not enforce attribute_a1 to be DataClass, but only limit __init__ method to it. Were it another method (not __init__, but, say, set_attribute_a1 - let's forget about properties for now), you would also violate LSP this way.
I can suggest two ways to go:
Generic
I'd assume BaseClass and DataClass definitions as yours. Then the following will work:
from typing import Generic, TypeVar
_T = TypeVar('_T', bound=BaseClass)
class BaseActionClass(Generic[_T]):
def __init__(self, attribute_a1: _T, attribute_a2: dict[str, str]) -> None:
self.attribute_a1: _T = attribute_a1
self.attribute_a2 = attribute_a2
def do_action_one(self) -> None:
pass
class ActionClass(BaseActionClass[DataClass]):
# Note you don't even need to override __init__ now, it follows from generic defn
def do_action_one(self) -> None:
self.attribute_a1.attribute_1
self.attribute_a1.attribute_2
Direct
class BaseActionClass:
def __init__(self, attribute_a1: BaseClass, attribute_a2: dict[str, str])
self.attribute_a1 = attribute_a1
self.attribute_a2 = attribute_a2
def do_action_one(self):
pass
def do_action_two(self):
pass
class ActionClass(BaseActionClass):
attribute_1: DataClass
def __init__(self, attribute_a1: DataClass, attribute_a2: dict[str, str]):
super().__init__(attribute_a1, attribute_a2)
def do_action_one(self):
self.attribute_a1.attribute_1
self.attribute_a1.attribute_2
The former solution is preferred, because it reveals your intention initially and is more semantically correct. It means roughly the following: class BaseActionClass has attribute_a1 parameter of type _T, which can be substituted by any BaseClass subclass (including BaseClass itself). When you subclass BaseActionClass[DataClass], you enforce _T substitution with DataClass. You can still do BaseActionClass(BaseClass(), {}) and _T will be BaseClass, but ActionClass(BaseClass(), {}) is rejected now.
The latter solution is much less elegant. I'd advice to use it only if you don't have access to modify BaseActionClass (for example, it is 3rd-party module and you don't want/can't create a PR to it).