YT-PYCC-9: Add the inherit_constructor parameter

Added the `inherit_constructor` parameter to the `const_class` decorator and unit tests covering the added functionality.

Author: SpectraL519

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyconstclasses"
-version = "0.5"
+version = "0.8"
 description = "Package with const class decoratos and utility"
 authors = [
     {name = "SpectraL519"}

src/constclasses/const_class.py

@@ -1,17 +1,32 @@
 from .ccerror import ConstError, InitializationError
-from .const_class_base import CC_BASE_ATTR_NAME, ConstClassBase
+from .const_class_base import (
+    CC_BASE_ATTR_NAME,
+    CC_INITIALIZED_ATTR_NAME,
+    ConstClassBase,
+)
 
 
 def const_class_impl(
-    cls, with_kwargs: bool, with_strict_types: bool, include: set[str], exclude: set[str]
+    cls,
+    with_kwargs: bool,
+    with_strict_types: bool,
+    include: set[str],
+    exclude: set[str],
+    inherit_constructor: bool,
 ):
     class ConstClass(cls):
         def __init__(self, *args, **kwargs):
-            super(ConstClass, self).__init__()
-
             self.__dict__[CC_BASE_ATTR_NAME] = ConstClassBase(
                 with_strict_types=with_strict_types, include=include, exclude=exclude
             )
+            self.__dict__[CC_INITIALIZED_ATTR_NAME] = False
+
+            if inherit_constructor:
+                super(ConstClass, self).__init__(*args, **kwargs)
+                self._cc_initialized = True
+                return
+            else:
+                super(ConstClass, self).__init__()
 
             if with_kwargs:
                 for attr_name, attr_type in cls.__annotations__.items():
@@ -29,8 +44,10 @@ def __init__(self, *args, **kwargs):
                         attr_name, attr_type, args[i]
                     )
 
+            self._cc_initialized = True
+
         def __setattr__(self, attr_name: str, attr_value) -> None:
-            if self._cc_base.is_const_attribute(attr_name):
+            if self._cc_initialized and self._cc_base.is_const_attribute(attr_name):
                 raise ConstError(cls.__name__, attr_name)
             self.__dict__[attr_name] = self._cc_base.process_attribute_type(
                 attr_name, cls.__annotations__.get(attr_name), attr_value
@@ -50,8 +67,11 @@ def const_class(
     with_strict_types: bool = False,
     include: set[str] = None,
     exclude: set[str] = None,
+    inherit_constructor=False,
 ):
     def _wrap(cls):
-        return const_class_impl(cls, with_kwargs, with_strict_types, include, exclude)
+        return const_class_impl(
+            cls, with_kwargs, with_strict_types, include, exclude, inherit_constructor
+        )
 
     return _wrap if cls is None else _wrap(cls)

src/constclasses/const_class_base.py

@@ -9,11 +9,18 @@ class ConstClassBase:
     def __init__(
         self,
         /,
+        cls_attrs: set[str] = set(),
         *,
         include: set[str] = None,
         exclude: set[str] = None,
         with_strict_types: bool = False,
     ):
+        intersection = cls_attrs & MANDATORY_CONST_ATTRS
+        if intersection:
+            raise ConfigurationError(
+                f"Const class cannot have members: [{', '.join(intersection)}]"
+            )
+
         if include is not None and exclude is not None:
             raise ConfigurationError(
                 "`include` and `exclude` parameters cannot be used simultaneously"

src/constclasses/static_const_class.py

@@ -12,11 +12,11 @@ def static_const_class_impl(
 ):
     class StaticConstClass(cls):
         def __init__(self, *args, **kwargs):
-            super(StaticConstClass, self).__init__(*args, **kwargs)
             self.__dict__[CC_BASE_ATTR_NAME] = ConstClassBase(
                 with_strict_types=with_strict_types, include=include, exclude=exclude
             )
             self.__dict__[CC_INITIALIZED_ATTR_NAME] = False
+            super(StaticConstClass, self).__init__()
 
         def __setattr__(self, attr_name: str, attr_value) -> None:
             if self._cc_initialized and self._cc_base.is_const_attribute(attr_name):

test/common/utility.py

@@ -5,6 +5,10 @@ def msg(err: Exception) -> str:
     return str(err.value)
 
 
+def config_not_empty_cls_attrs_intersection_msg_prefix() -> str:
+    return "Const class cannot have members"
+
+
 def config_include_and_exclude_used_error_msg_postfix() -> str:
     return "`include` and `exclude` parameters cannot be used simultaneously"
 

test/test_const_class.py

@@ -176,3 +176,25 @@ class ConstClassStrictTypes:
         with pytest.raises(TypeError) as err:
             setattr(const_instance, attr_name, DUMMY_VALUE)
         assert util.msg(err).startswith(util.invalid_type_error_msg_prefix())
+
+
+def test_initialization_with_inherited_constructor():
+    @const_class(inherit_constructor=True)
+    class ConstClassWithConstructor:
+        x: int
+        s: str
+
+        def __init__(self, x: int):
+            self.x = x
+            self.s = str(x)
+
+    x_value = ATTR_VALS_1[X_ATTR_NAME]
+    const_instance = None
+
+    def _initialize():
+        nonlocal const_instance
+        const_instance = ConstClassWithConstructor(x_value)
+
+    util.assert_does_not_throw(_initialize)
+    assert const_instance.x == x_value
+    assert const_instance.s == str(x_value)

test/test_const_class_base.py

@@ -5,7 +5,18 @@
 from constclasses.const_class_base import MANDATORY_CONST_ATTRS, ConstClassBase
 
 
-def test_const_class_base_setup_for_not_none_include_and_exclude_parameters():
+def test_init_for_class_attrs_intersecting_with_mandatory_const_attrs():
+    for attr_name in MANDATORY_CONST_ATTRS:
+        with pytest.raises(ConfigurationError) as err:
+            _ = ConstClassBase(cls_attrs={attr_name})
+        assert util.config_not_empty_cls_attrs_intersection_msg_prefix() in util.msg(err)
+
+    with pytest.raises(ConfigurationError) as err:
+        _ = ConstClassBase(cls_attrs=MANDATORY_CONST_ATTRS)
+    assert util.config_not_empty_cls_attrs_intersection_msg_prefix() in util.msg(err)
+
+
+def test_init_for_not_none_include_and_exclude_parameters():
     with pytest.raises(ConfigurationError) as err:
         _ = ConstClassBase(include={}, exclude={})
 
@@ -14,7 +25,7 @@ def test_const_class_base_setup_for_not_none_include_and_exclude_parameters():
     )
 
 
-def test_const_class_base_setup_for_exclude_intersecting_with_mandatory_const_fields():
+def test_init_for_exclude_intersecting_with_mandatory_const_fields():
     for mandatory_const_attr in MANDATORY_CONST_ATTRS:
         with pytest.raises(ConfigurationError) as err:
             _ = ConstClassBase(exclude={mandatory_const_attr})
@@ -31,6 +42,13 @@ def test_const_class_base_setup_for_exclude_intersecting_with_mandatory_const_fi
     assert err_msg.endswith(util.config_invalid_exclude_error_msg(MANDATORY_CONST_ATTRS))
 
 
+def test_init_with_valid_parameter_configuration():
+    def _test():
+        _ = ConstClassBase()
+
+    util.assert_does_not_throw(_test)
+
+
 @pytest.fixture
 def gen_attributes():
     no_attrs = 8