I’ve realised that you can use dummy methods to collect and re-use parameter dependencies, and also define a kind of recursive dependency (see example below). I haven’t seen this use of the ‘depend-on-method’ feature mentioned in the docs or sample code that I’ve read.
Two questions:
- Can anyone think of ways this trick might cause me some kind of problems in the future?
- Is there a less hacky, officially sanctioned way to do this?
import param
class Foo(param.Parameterized):
a = param.Parameter()
b = param.Parameter()
c = param.Parameter()
d = param.Parameter()
e = param.Parameter()
def _all_params(self): # this method depends on all params!
pass
@param.depends("a", "e")
def _vowels(self):
pass
@param.depends("b", "c", "d")
def _consonants(self):
pass
@param.depends("a._vowels", "a._sub_vowels_a")
def _sub_vowels_a(self):
pass
@param.depends("_all_params")
def method1(self):
pass
@param.depends("_vowels")
def method2(self):
pass
@param.depends("_consonants")
def method3(self):
pass
@param.depends("_vowels", "_consonants")
def method4(self):
pass
@param.depends("_sub_vowels_a")
def method5(self):
pass
foo = Foo(name="outer", a=Foo(name="inner", a=Foo(name="innermost")))
for m in ["method1", "method2", "method3", "method4", "method5"]:
print(m)
dependencies = foo.param.method_dependencies(m)
print([f"{o.inst.name}.{o.pobj.name}:{o.what}" for o in dependencies])
method1
['outer.name:value', 'outer.a:value', 'outer.b:value', 'outer.c:value', 'outer.d:value', 'outer.e:value']
method2
['outer.a:value', 'outer.e:value']
method3
['outer.b:value', 'outer.c:value', 'outer.d:value']
method4
['outer.a:value', 'outer.e:value', 'outer.b:value', 'outer.c:value', 'outer.d:value']
method5
['inner.a:value', 'inner.e:value', 'innermost.a:value', 'innermost.e:value']