from functools import cached_property
import inspect

class Parent:
    @cached_property
    def foo(self):
        "this is the docstring for foo"
        return 1

class Child(Parent):
    @cached_property
    def foo(self): ...

assert inspect.getdoc(Child.foo) == inspect.getdoc(Parent.foo) # fails but we want this to be True

from functools import cached_property
import inspect

import unittest


class TestMatchingDocstrings(unittest.TestCase):
    def setUp(self):
        self.parent_class = ParentClass
        self.child_class = ChildClass

    def compare_docstrings(self, attrname):
        parent_attr = getattr(self.parent_class, attrname)
        parent_docstring = inspect.getdoc(parent_attr)
        child_attr = getattr(self.child_class, attrname)
        child_docstring = inspect.getdoc(child_attr)
        self.assertEqual(parent_docstring, child_docstring)

    def test_method_defined_in_parent_only(self):
        self.compare_docstrings("method_defined_in_parent_only")

    def test_method_defined_in_parent_and_child(self):
        self.compare_docstrings("method_defined_in_parent_and_child")

    def test_property_defined_in_parent_only(self):
        self.compare_docstrings("property_defined_in_parent_only")

    def test_property_defined_in_parent_and_child(self):
        self.compare_docstrings("property_defined_in_parent_and_child")

    def test_cached_property_defined_in_parent_only(self):
        self.compare_docstrings("cached_property_defined_in_parent_only")

    def test_cached_property_defined_in_parent_and_child(self):
        self.compare_docstrings("cached_property_defined_in_parent_and_child")

    def test_static_method_defined_in_parent_only(self):
        self.compare_docstrings("static_method_defined_in_parent_only")

    def test_static_method_defined_in_parent_and_child(self):
        self.compare_docstrings("static_method_defined_in_parent_and_child")

    def test_class_method_defined_in_parent_only(self):
        self.compare_docstrings("class_method_defined_in_parent_only")

    def test_class_method_defined_in_parent_and_child(self):
        self.compare_docstrings("class_method_defined_in_parent_and_child")


class ParentClass:
    def method_defined_in_parent_only(self):
        "This is a method in the parent only"

    def method_defined_in_parent_and_child(self):
        "This is a method in the parent and child"

    @property
    def property_defined_in_parent_only(self):
        "This is a property with the decorator in the parent only"

    @property
    def property_defined_in_parent_and_child(self):
        "This is a property with the decorator in the parent and child"

    @cached_property
    def cached_property_defined_in_parent_only(self):
        "This is a cached property with the decorator in the parent only"

    @cached_property
    def cached_property_defined_in_parent_and_child(self):
        "This is a cached property with the decorator in the parent and child"

    @staticmethod
    def static_method_defined_in_parent_only():
        "This is a static method with the decorator in the parent only"

    @staticmethod
    def static_method_defined_in_parent_and_child():
        "This is a static method with the decorator in the parent and child"

    @classmethod
    def class_method_defined_in_parent_only(cls):
        "This is a class method with the decorator in the parent only"

    @classmethod
    def class_method_defined_in_parent_and_child(cls):
        "This is a class method with the decorator in the parent and child"


class ChildClass(ParentClass):
    def method_defined_in_parent_and_child(self): ...

    @property
    def property_defined_in_parent_and_child(self): ...

    @cached_property
    def cached_property_defined_in_parent_and_child(self): ...

    @staticmethod
    def static_method_defined_in_parent_and_child(): ...

    @classmethod
    def class_method_defined_in_parent_and_child(cls): ...


if __name__ == "__main__":
    unittest.main()