property resolution fixed

Author: kpe

params/params.py

@@ -14,7 +14,7 @@
 
 class Param:
     """ Provides a parameter specification to be used within a Params instance. """
-    def __init__(self, value, doc: Text = None, dtype: Type = None, required: bool = False):
+    def __init__(self, value, doc: Text = None, dtype: Type = None, required: bool = False, params_class=None):
         """
         Constructs a parameter specification to be used in a Params instance:
 
@@ -31,17 +31,28 @@ class MyParams(pp.Params):
         :param dtype: (Optional) type
         :param required:  default is True.
         """
-        self.default_value = value
+        self.params_class = params_class
+        self._default_value = value
         self.doc_string = doc
         self.required = required
-        self.dtype = type(value) if (dtype is None and value is not None) else dtype
-        if value is not None:
+        self.dtype = dtype
+        if dtype is None and value is not None and not callable(value):
+            self.dtype = type(value)
+        if value is not None and not callable(value):
             if not isinstance(value, self.dtype):
                 raise RuntimeError(f"Param({value}) does not match dtype:[{self.dtype}]")
         self.name = None
+        self.is_property = callable(value)
 
+    @property
+    def default_value(self):
+        return self._default_value(self.params_class) if self.is_property else self._default_value
 
-class Params(dict):  # TODO use collections.UserDict instead of dict - see #1
+    def value(self, params):
+        return self._default_value(params) if self.is_property else getattr(self.name, params)
+
+
+class Params(dict):
     """ Base class for defining safe parameter dictionaries.
 
     Example:
@@ -67,37 +78,48 @@ class MyParams(pp.Params):
 
     def __init_subclass__(cls, **kwargs):
         """ Aggregates the Param spec of the parameters over the hierarchy. """
-        specs = {}
-        for base in reversed(cls.__bases__):
+        base_specs = {}
+        for base in cls.__bases__:
             if issubclass(base, Params):
-                specs.update(base.__specs)
+                base_specs.update(base.__specs)
 
+        cls_specs = []  # evaluate in order of declaration
         for attr, value in cls.__dict__.items():
             if attr.startswith("_") or callable(getattr(cls, attr)):
                 continue
 
-            param_spec = getattr(cls, attr)
-            if isinstance(param_spec, property):
-                param_spec = Param(param_spec.fget(cls))
-            elif not isinstance(param_spec, Param):
+            attr_val = getattr(cls, attr)
+            if isinstance(attr_val, property):
+                param_spec = Param(attr_val.fget, params_class=cls)
+            elif not isinstance(attr_val, Param):
                 param_spec = Param(value)
+            else:
+                param_spec = attr_val
 
             param_spec.name = attr
-            specs[attr] = param_spec
+            cls_specs.append((attr, param_spec))
 
-        for attr, value in specs.items():
+        _specs = {}
+        for attr, value in list(base_specs.items()) + cls_specs:
             setattr(cls, attr, value.default_value)
+            _specs[attr] = value
 
-        cls.__specs = specs
+        cls.__specs = _specs
         cls.__defaults = {key: val.default_value for key, val in cls.__specs.items()}
 
     def __init__(self, *args, **kwargs):
         super(Params, self).__init__()
         self.update(self.__defaults)   # start with default values
         self.update(dict(*args))       # override with tuple list
         self.update(kwargs)            # override with kwargs
+        # update any overridden @property parameters
+        prop_specs = list(filter(lambda spec: spec.is_property,
+                                 self.__class__.__specs.values()))
 
-    def update(self, arg=None, **kwargs):
+        for spec in prop_specs:
+            self.update({spec.name: spec.value(self)})
+
+    def update(self, arg=None, **kwargs):   # see dict.update()
         if arg:
             keys = getattr(arg, "keys") if hasattr(arg, "keys") else None
             if keys and (inspect.ismethod(keys) or inspect.isbuiltin(keys)):
@@ -111,7 +133,10 @@ def update(self, arg=None, **kwargs):
 
     def __getattribute__(self, attr):
         if not attr.startswith("_") and attr in self.__defaults:
-            return self.__getitem__(attr)
+            if self.__specs[attr].is_property:
+                return self.__specs[attr].value(self)
+            else:
+                return self.__getitem__(attr)
         return object.__getattribute__(self, attr)
 
     def __setattr__(self, key, value):

tests/test_subclassing.py

@@ -7,70 +7,93 @@
 
 import unittest
 
-from params import Params
+import params as pp
 
 
-class BaseParams(Params):
-    param_a = True
-    param_b = 1
+class BaseParams(pp.Params):
+    param_a = "a"
+    param_b = "b"
 
 
 class SubParams(BaseParams):
-    param_c = 'a'
-    param_a = False
+    param_a = "Sa"
+    param_c = "Sc"
 
 
 class SubParamsA(SubParams):
-    param_d = 'A'
-    param_e = False
+    param_d = "aD"
+    param_e = "aE"
 
 
 class SubParamsB(SubParams):
-    param_f = 'B'
-    param_g = False
+    param_f = 'SBf'
+
+    @property
+    def param_g(self):
+        return "SBBg_" + self.param_b
+
+    @property
+    def param_a(self):
+        return "SBBa_" + self.param_g + self.param_c
 
 
 class MySubParams(SubParamsA, SubParamsB):
-    param_h = 'a'
-    param_j = False
+    param_h = "MSh"
+    param_j = "MSj"
 
     @property
-    def param_f(self):
-        return 'F'
+    def param_c(self):
+        return "MSc_" + self.param_g
+
+
+class AnotherSubParams(MySubParams):
+    @property
+    def param_h(self):
+        return "ASh_" + self.param_d
+
+    @property
+    def param_g(self):
+        return "ASg_" + self.param_h
+
 
 
 class ParamsSubclassingTest(unittest.TestCase):
     def test_subclassing(self):
-        Params()
         params = SubParams()
-        expected = {'param_a': False, 'param_b': 1, 'param_c': 'a'}
+        expected = {"param_a": "Sa", "param_b": "b", "param_c": "Sc"}
         self.assertEqual(dict(params), expected)
 
-        params = SubParams(param_b=2)
-        params.param_c = 'b'
-        params.param_a = True
-        expected = {'param_a': True, 'param_b': 2, 'param_c': 'b'}
+        params = SubParams(param_b="bb")
+        params.param_c = "cc"
+        params.param_a = "aa"
+        expected = {"param_a": "aa", "param_b": "bb", "param_c": "cc"}
         self.assertEqual(dict(params), expected)
 
         params = BaseParams()
         try:
-            params.param_c = 'c'
+            params.param_c = "cc"
             self.fail()
         except AttributeError:
             pass
 
-        params = SubParams(param_b=2).clone(param_c=3)
-        expected = {'param_b': 2, 'param_a': False, 'param_c': 3}
+        params = SubParams(param_b="bb").clone(param_c="cc")
+        expected = {"param_b": "bb", "param_a": "Sa", "param_c": "cc"}
         self.assertEqual(dict(params), expected)
 
     def test_hierarchy(self):
-        params = MySubParams()
-        self.assertEqual(params.param_b, 1)
-        self.assertEqual(params.param_a, False)
+        params = MySubParams(param_f="SBf")
+        self.assertEqual(params.param_b, "b")
+        self.assertEqual(params.param_a, "SBBa_SBBg_bMSc_SBBg_b")
+
         MySubParams.to_argument_parser().print_help()
 
-        self.assertEqual(params.param_f, "F")
-        self.assertEqual(MySubParams.param_f, "F")
+        self.assertEqual(params.param_f, "SBf")
+        self.assertEqual(MySubParams.param_f, "SBf")
+
+    def test_hierarchy_override(self):
+        params = AnotherSubParams(param_d='Z')
+        self.assertEqual(params.param_g, "ASg_ASh_Z")
+
 
 if __name__ == '__main__':
     unittest.main()