Param: Make your Python code clearer and more reliable by declaring Parameters

Very WIP PR to illustrate an idea we have been discussing. The API will probably change but here is the current behavior:

The idea is to add a new Trigger parameter type which would replace many uses of Action. What you want to know about a Trigger parameter is whether it has been triggered (e.g a button clicked). The value is True if the parameter has just been triggered, otherwise False (which means a trigger call has happened since not involving that parameter).

One possibility which is more complicated is to avoid b.param.trigger('a') by setting b.a = True (setting to True triggers, whether or not the value is True already). This involves working inside __set__ which can get quite tricky.

At this point, this PR aims to be a place to discuss this suggestion more than something to merge. The idea is that this parameter would mean https://github.com/holoviz/holoviews/pull/4611 is not necessary (though panel would need to be updated to display this parameter type as appropriate buttons).

TODO

• [x] Make this work with class parameters (doesn't work with Bar at the moment in the example above)
• [ ] Improve API, possibly via __set__

I've re-implemented ParamOverrides, following the suggestion made in #85 about sharing parameter objects. This PR isn't meant for merging at this stage, I'd just like some comments on the basic idea.

This new implementation passes all the tests (including one I added to check that dynamic overrides work), although the implementation's not yet complete (just missing some minor methods that the current ParamOverrides has). However, what I'd like to know is: is the whole idea crazy? If it's not crazy, is there a way to make the implementation simpler? I've left extra comments in the code for now to explain what I was thinking.

In case it's easier to look at the class in one piece: https://github.com/ceball/param/blob/bug85_newParamOverrides/param/parameterized.py#L1580

(Also, note that I haven't considered speed.)

I'm pulling some suggestions out of #160 to file as a separate issue. As it turns out there are different things we might want to have param express:

1. Relationships between parameters i.e update parameter settings based on changes to another parameter. There may be some easy way to express such relationship or there might be some code supplied by the user to link parameters (e.g using the set_hook idea)
2. Relationships between parameters and regular code in parameterized classes that might consume parameter values and/or set them. This is what this issue is about and the idea is to express that a method might make use of a parameter and might set other parameters. If the method has output, you may make the assumption that the output will have changed when the parameters that are read by that method have changed.
3. General specifications of input/output types of methods, functions etc. This would be very useful for some things but currently out of the scope of what we want to achieve in the short term.

Here are my proposals to address 2. made in issue #160:

class Example(param.Parameterized):

    A = param.Number(default=10)

    B = param.Number(default=5)

    @param.dependencies([A],[B])
    def link_a_to_b(self, **parameters):
        self.B = parameters['A']/2.

This expresses the parameters read ([A]) and the parameters written to ([B]) using a decorator. Alternatively, you could have more granular decorators:

class Example(param.Parameterized):

    A = param.Number(default=10)

    B = param.Number(default=5)

    @param.reads([A])
    @param.writes([B])
    def link_a_to_b(self, **parameters):
        self.B = parameters['A']/2.

The information captured by the decorator needs to be stored somewhere. Presumably we don't want either 1) a global mapping of parameterized classes and their parameter dependencies as this would be fragile 2) distributing this information among the parameters themselves (would be very space inefficient if each parameter holds such information). This means the natural place to keep track of this is in the parameterized classes, presumably somewhere in param.Parameterized.

The limitation of this is 1) it wouldn't be customizable per instance 2) it would be information defined once when the class is defined. Neither of these seems to be a real problem as we don't often shove/mutate methods on classes after they are defined.

As for API, I really would like #154 tackled (putting the API onto a sub-object) first but that seems unlikely to happen. Here is one simple idea of how the information could be accessed:

example = Example()
reads, writes = example.param_dependencies('link_a_to_b') # OR
reads, writes = Example.param_dependencies('link_a_to_b') 

This just regurgitates what was supplied to the @param.dependencies decorator where the reads and writes might be empty lists. I'm not sure whether these lists should just contain parameter names or the parameter objects themselves. Maybe this could be an optional argument to the param_dependencies method where I would favor names by default.

One thing worth mentioning is by making certain assumptions you could follow a chain of changes without executing user code. For instance, if you assume that changing parameter a read by method1 changes parameter b that it writes to, you might then assume that the output of method2 is changed as that method reads parameter b.

Note that this proposal simply aims to capture the which parameters are read/written to by methods and doesn't aim to do anything with this information. I have no particular proposals for this just yet but I can imagine param offering utilities to trace the potential dependency graph of parameters and perhaps execute various sorts of callback when parameters change.

This PR is still WIP. There are a lot of lines changed from the very first commit as this was the sort of task I couldn't tell would be viable until it was all done.

In short it moves most of the code of Parameterized onto a param objects of type Parameters which also acts as a namespace. The goal is to make this the face of the public API cleaning up the namespace of classes subclassed by users. Here is an example for a bothmethod params:

HOW IT WORKS

• Parameters is instantiated by the metaclass or the regular constructor.
• All methods use self_ as the first argument.
• Classmethods have the first line cls = self_.cls after which the code is unchanged.
• Bothmethods have the first line self_or_cls = self_.cls if self_.self is None else self_.self after which the code is unchanged.
• Instance methods have the first line self = self_.self after which the code is unchanged.
• Double underscore methods need special handling (see below) but thankfully they are rare.

Notes:

• The param object is per instance when necessary allowing it to hold state either at the class or instance level: this will be important for recording information regarding parameter dependencies etc.
• Methods decorated with @as_uninitialized are used in the Parameterized constructor and I have left them on that class.
• I have left the 'special' methods on Parameterized (e.g __repr__)
• The only exception to the above is _instantiate_param which I can move as it used __dict__ and is used from the Parameterized constructor via _setup_params
• I have tried to organized methods by their type: classmethods, then bothmethods and finally instance methods. Within these groups I aimed for rough semantic grouping.
• Double underscore methods need to be moved to Parametersand accessed through self_ to avoid Python name mangling issues. This came up for __db_print in particular.
• self_or_cls, cls_or_self, cls_or_slf or slf_or_cls? I have seen at least three of these...
• The actual API could do with some clean up. It is definitely redundant in places...

TODO

• [x] Fix issue with existing nosetests
• [x] Transfer methods for ParameterizedFunction? [Yes except for .instance]
• [x] Add more tests [copy existing tests and update]
• [x] Transfer docstrings to aliased methods?
• [x] Update internal API to use .param namespace so we can just delete the aliases when the time comes.
• [x] We need a decorator or some other approach to issue deprecation warnings when not using the param object to migrate users to the namespace object.
• [x] Try to move the @as_uninitialized and special methods too? [Yes]

This PR implements the notion of an instance parameter which can be accessed using a new API. All parameters can in theory become instance parameters (as long as the new per_instance slot is set to True). The main balance to strike here is that a) we do not want to pay the cost of copying parameters for all instances and b) we do not want users to have to add any special boilerplate to get instance parameters.

The approach I've therefore taken is to only make a copy of a parameter when it is actually needed. This means that all existing param code will never pay the cost of making instance parameters, there's only two situations where the per instance copy is made:

1. When a instance parameter attribute is watched. This is because you do not want events triggered by changes on the class parameter to trigger events on the instance parameter and vice versa.
2. The second situation when a copy is made is when one of the new APIs is used to access the parameter on an instance, e.g. when you access instance.param.param_name or instance.param['param_name']. This API will make it easy to change the attributes of instance parameters, but the old obj.params()/obj.param.params() method is unaffected by this.

Leaving the old API unaffected will ensure that old param code never pays the costs associated with instance parameters.

• [x] Add new parameterized.param.__getitem__ and parameterized.param.__getattr__ accessors for parameters
• [x] Modify setters to ensure they use instance parameters for validation
• [x] Ensure that watching instance parameter attributes makes copies
• [x] Add tests

Hello,

i try to add my own information to param.Parameter instances by subclassing it

here is my attempt (the additional information that i want to store in parameters is whether they should remain enabled in the graphic interface when a run has started)

import param as pm

# Add run_enabled slot to pm.Parameter classes
class RunEnabledInfo:

    __slots__ = ['run_enabled']

    def __init__(self, *args, run_enabled=None, **kwargs):
        super(MyBoolean, self).__init__(*args, **kwargs)
        self.run_enabled = run_enabled

class MyBoolean(pm.Boolean, RunEnabledInfo):
    pass

class MyNumber(pm.Number, RunEnabledInfo):
    pass

But i get

Traceback (most recent call last):
  File "E:/Users/Thomas/Python/Naivia/AlphaI/test.py", line 18, in <module>
    class MyBoolean(pm.Boolean, RunEnabledInfo):
  File "C:\ProgramData\Anaconda3\lib\site-packages\param\parameterized.py", line 503, in __new__
    return type.__new__(mcs,classname,bases,classdict)
TypeError: multiple bases have instance lay-out conflict

The problem seems to be with MyBoolean inheriting from two classes. Indeed the following code works, but i wouldn't like to rewrite it for every possible parameter type! Any suggestion how to do?

class MyBoolean(pm.Boolean):

    __slots__ = ['run_enabled']

    def __init__(self, *args, run_enabled=None, **kwargs):
        super(MyBoolean, self).__init__(*args, **kwargs)
        self.run_enabled = run_enabled

This PR is a prototype that replaces set_hook on Number with a more general system of pre- and post- setting hooks. This may be useful for things like linking streams or eventual unit support in param.

An example of what this might be useful for is shown in ioam/holoviews#1740.

I'm not quite sure about the appropriate signatures for the hooks right now and this PR will probably need quite a bit of discussion before we are agreed on the appropriate approach.

Introduction

This implements my suggestion for better IPython support (#71).

In the end, this was surprisingly easy to implement! Nothing particularly fancy is going on here but I have made this feature optional. You can disable this behavior using the DOCSTRING_SIGNATURE global variable.

Given that the time taken for class definition (e.g. on import) is rarely a performance issue, this global flag might not be necessary (assuming you are happy enabling this behavior by default).

Demo

class Foo(param.Parameterized):
    """
    This is the Foo class.
    """

    foo = param.Number(default=42)

    def __init__(self, **kwargs):
        super(Foo, self).__init__(**kwargs)

Now if in IPython Notebook I do:

>>> Foo(

I see the following pop-up message:

Foo(self, **kwargs)

Foo(*args, **kwargs, foo=42)

(The first useless line is automatically generated by IPython - it would be nice to suppress it!)

If I now press the + button, the pop-up expands to show the following message underneath:

This is the Foo class.

Note that if a docstring is explicitly supplied to the __init__ method, it will be left untouched.

The crucial features is that you can now tab-complete the 'foo' keyword and see a list all the parameters by pressing TAB (before a unique match is specified).

Limitations

• I simply sort all the keywords alphanumerically. A fancier implementation could list parameters according to the method resolution order (mro).
• The values used in the signature are not updated if the user overrides the default values of class parameters.
• Param seems to do something special if there is no __init__ for the particular subclass. For instance:

class Bar(Foo):

    bar = param.String(default='bar')

>>> print Bar.__init__.__doc__
        Initialize this Parameterized instance.

        The values of parameters can be supplied as keyword arguments
        to the constructor (using parametername=parametervalue); these
        values will override the class default values for this one
        instance.

        If no 'name' parameter is supplied, self.name defaults to the
        object's class name with a unique number appended to it.

• The auto-generated signature created by IPython is useless and annoying. Maybe this is something we could disable for Parameterized objects in the IPython extension?
• Perhaps if the output is particularly good, this could replace the %params magic, listing all the parameters together with their docstrings? Note that pressing the ^ button expands all the output in the pager (which is where the %param magic also displays its output).
• No fancy string formatting. Perhaps this is a feature. :-)

Conclusion

For now, I just want to sketch out a basic implementation in this PR. The inclusion of fancier features and improvements now depend on your feedback!

Edit: Bar inherits from Foo.

Maybe I'm not calling this correctly?

foo = param.DataFrame(columns=3) results in:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-2-526280bfed91> in <module>
      5 # class test(param.Parameterized):
      6 #     df = param.DataFrame(rows=3, columns=4)
----> 7 foo = param.DataFrame(columns=3)

~/ers/gitHub/param/master/param/param/__init__.py in __init__(self, rows, columns, ordered, **params)
   1313         self.columns = columns
   1314         self.ordered = ordered
-> 1315         super(DataFrame,self).__init__(pdDFrame, allow_None=True, **params)
   1316         self._check_value(self.default)
   1317 

~/ers/gitHub/param/master/param/param/__init__.py in __init__(self, class_, default, instantiate, is_instance, **params)
   1150         self.is_instance = is_instance
   1151         super(ClassSelector,self).__init__(default=default,instantiate=instantiate,**params)
-> 1152         self._check_value(default)
   1153 
   1154 

~/ers/gitHub/param/master/param/param/__init__.py in _check_value(self, val, obj)
   1348                 raise ValueError(msg.format(found=list(val.columns), expected=sorted(self.columns)))
   1349         else:
-> 1350             self._length_bounds_check(self.columns, len(val.columns), 'Column')
   1351 
   1352         if self.ordered:

AttributeError: 'NoneType' object has no attribute 'columns'

And

foo = param.DataFrame(rows=3)

results in:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-eff4207c7467> in <module>
      5 # class test(param.Parameterized):
      6 #     df = param.DataFrame(rows=3, columns=4)
----> 7 foo = param.DataFrame(rows=3)

~/ers/gitHub/param/master/param/param/__init__.py in __init__(self, rows, columns, ordered, **params)
   1313         self.columns = columns
   1314         self.ordered = ordered
-> 1315         super(DataFrame,self).__init__(pdDFrame, allow_None=True, **params)
   1316         self._check_value(self.default)
   1317 

~/ers/gitHub/param/master/param/param/__init__.py in __init__(self, class_, default, instantiate, is_instance, **params)
   1150         self.is_instance = is_instance
   1151         super(ClassSelector,self).__init__(default=default,instantiate=instantiate,**params)
-> 1152         self._check_value(default)
   1153 
   1154 

~/ers/gitHub/param/master/param/param/__init__.py in _check_value(self, val, obj)
   1356 
   1357         if self.rows is not None:
-> 1358             self._length_bounds_check(self.rows, len(val), 'Row')
   1359 
   1360     def __set__(self,obj,val):

TypeError: object of type 'NoneType' has no len()

This PR outlines another attempt at serializing/deserializing to JSON (for reference see #153 for earlier attempts at tackling this problem). The design used in this PR aims to try to keep things simpler but also adds the ability to generate JSON Schemas which should help with testing as well as specification of allowable parameter values (e.g this could be used to specify suitable widgets in panel).

This PR is based off the ideas suggested in #382.

TODO:

• [ ] The main open problem is about finding the appropriate API and JSON (and schema) representation for entire parameterized objects (i.e including the class identity as well as all the parameters).

This PR adds something I've long wished for in param: sensible, short reprs that actually work. :-)

Although I started implementing this in __repr__, I saw the note about repr needing to be fast and then decided against implementing it there once I realized what was required.

Instead of changing __repr__, I've ended up making a more robust pprint function that can be used as follows:

class Foo(param.Parameterized):

    a = param.Number(4, precedence=6)

    b = param.String('B', precedence=-9)

    c = param.Number(4, precedence=0)

    z = param.Number(4, precedence=0)

    def __init__(self, a, b, c=4, d=99, **kwargs):
        self.d = d
        super(Foo, self).__init__(a=a, b=b, c=c, **kwargs)

    def __repr__(self):
        return param.parameterized.pprint(self, {'d':self.d})

First the positional arguments are shown as their appropriate values. Then modified keyword arguments are shown in the order they are declared in. Then the varargs (e.g *varargs) is shown (if present). Then if a keyword dictionary (i.e. **kwargs) is present, it is assumed that the modified parameters can then be listed in order of their precedence.

Here are some examples:

>>> Foo(1,'C')
Foo(1, 'C')

# Positional arguments always shown even if at default values
>>> Foo(4,'B')  
Foo(4,'B')

# Keyword not shown if supplied at default value
>>> Foo(4,'B', c=4) 
Foo(4,'B')

>>> Foo(4, 'B', c=5)
Foo(4, 'B', c=5)

# 'd' is not a parameter (supplied at the default value)
>>> Foo(4,'B', c=5, d=99)   
Foo(4, 'B', c=5)

>>> Foo(4,'B', c=5, d=100)
 Foo(4,'B', c=5, d=100)

>>>  Foo(4,'B', z=44, d=100)
 Foo(4,'B', z=44, d=100)

>>>  Foo(4,'B', z=4, d=100)
Foo(4, 'B', d=100)

For comparison, here is an example of the default repr:

>>>Foo(4,'B')
Foo(a=4, b='B', c=4, name='Foo00456', z=4)

My main concern with pprint is performance. It might be nice to cache some of the results of the introspection for performance reasons.

EDIT: If you are happy with the addition of this function, I'll make sure to write a good number of unit tests for it.

The files in this pull request should act as examples of how other HoloViz projects could quickly adopt the default project docs using references to the project docs at holoviz/holoviz.

The maintainer list is based on the HoloViz Duties spreadsheet. All three maintainers should participate and/or approve.

I'll mention this at the next docs meeting, but I've written the guidance to create project docs. I'll update this if there are any further changes to this PR.

Thanks for contacting us! Please read and follow these instructions carefully, then delete this introductory text to keep your issue easy to read. Note that the issue tracker is NOT the place for usage questions and technical assistance; post those at Discourse instead. Issues without the required information below may be closed immediately.

ALL software version info

(this library, plus any other relevant software, e.g. bokeh, python, notebook, OS, browser, etc) param v 1.12.3 Reproducible at least on on python 3.10 on Ubuntu.

Description of expected behavior and the observed behavior

The error below is thrown when I try nested parameterized dependencies, where there is a watch on a nested dependency. I would expect that the watch flag should work in these circumstances.

Complete, minimal, self-contained example code that reproduces the issue

import param

class A(param.Parameterized):
    x=param.Number(default=0)

class B(param.Parameterized):
    a=param.ClassSelector(A, default=A())

    @param.depends('a.x', watch=True)
    def y(self):
        pass


class C(param.Parameterized):
    b=param.ClassSelector(B, default=B())



c = C()

Stack traceback and/or browser JavaScript console output

  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/IPython/core/interactiveshell.py", line 3398, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-2-c31ab72dd48f>", line 1, in <cell line: 1>
    runfile('/home/mats/.config/JetBrains/PyCharm2022.2/scratches/scratch_2.py', wdir='/home/mats/.config/JetBrains/PyCharm2022.2/scratches')
  File "/home/mats/.local/share/JetBrains/Toolbox/apps/PyCharm-P/ch-0/222.4345.23/plugins/python/helpers/pydev/_pydev_bundle/pydev_umd.py", line 198, in runfile
    pydev_imports.execfile(filename, global_vars, local_vars)  # execute the script
  File "/home/mats/.local/share/JetBrains/Toolbox/apps/PyCharm-P/ch-0/222.4345.23/plugins/python/helpers/pydev/_pydev_imps/_pydev_execfile.py", line 18, in execfile
    exec(compile(contents+"\n", file, 'exec'), glob, loc)
  File "/home/mats/.config/JetBrains/PyCharm2022.2/scratches/scratch_2.py", line 20, in <module>
    c = C()
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/param/parameterized.py", line 3173, in __init__
    self.param._setup_params(**params)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/param/parameterized.py", line 1387, in override_initialization
    fn(parameterized_instance, *args, **kw)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/param/parameterized.py", line 1633, in _setup_params
    self.param._instantiate_param(p)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/param/parameterized.py", line 1688, in _instantiate_param
    new_object = copy.deepcopy(param_obj.default)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 172, in deepcopy
    y = _reconstruct(x, memo, *rv)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 271, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 146, in deepcopy
    y = copier(x, memo)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 231, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 172, in deepcopy
    y = _reconstruct(x, memo, *rv)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 297, in _reconstruct
    value = deepcopy(value, memo)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 146, in deepcopy
    y = copier(x, memo)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 206, in _deepcopy_list
    append(deepcopy(a, memo))
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 172, in deepcopy
    y = _reconstruct(x, memo, *rv)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 265, in _reconstruct
    y = func(*args)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 264, in <genexpr>
    args = (deepcopy(arg, memo) for arg in args)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 172, in deepcopy
    y = _reconstruct(x, memo, *rv)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/copy.py", line 273, in _reconstruct
    y.__setstate__(state)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/param/parameterized.py", line 3227, in __setstate__
    watcher_args[2] = _m_caller(self, fn._watcher_name)
  File "/home/mats/miniconda3/envs/quant/lib/python3.10/site-packages/param/parameterized.py", line 661, in _m_caller
    function = getattr(self, method_name)
AttributeError: 'A' object has no attribute 'y'

When a default value is given to a ClassSelector (like in C above), a deepcopy of that default value happens, and it is the deepcopy that is causing the exception, so a shorter example wold be to just do:

import param
import copy

class A(param.Parameterized):
    x=param.Number(default=0)

class B(param.Parameterized):
    a=param.ClassSelector(A, default=A())

    @param.depends('a.x', watch=True)
    def y(self):
        pass

copy.deepcopy(B())

Removing the "watch" flag removes the issue, but I also lose the watched updates that I need.

ALL software version info

panel==0.14.2 param==1.12.3 jupyterlab==3.5.1

Description of expected behavior and the observed behavior

Expand button open and closes expansion on objectselector

Complete, minimal, self-contained example code that reproduces the issue

import param as pm
import panel as pn
pn.extension()


class A(pm.Parameterized):
    value = pm.String("Value A")
    
class B(pm.Parameterized):
    a = pm.ObjectSelector()

a = A()
b = B(a=a)

pn.Pane(b)

pn.Pane(b, expand=True, expand_button=True)

Stack traceback and/or browser JavaScript console output

Screenshots or screencasts of the bug in action

Clicking the blue buttons does nothing.

ALL software version info

param 1.12.2

Description of expected behavior and the observed behavior

From the API reference:

set_dynamic_time_fn(time_fn, sublistattr=None)[source] Set time_fn for all Dynamic Parameters of this class or instance object that are currently being dynamically generated.

Either I am completely misunderstanding this/using it wrong, or it just doesn't do that. The time_fn is unaffected.

Additionally, sets _Dynamic_time_fn=time_fn on this class or instance object, ...

This is true.

... so that any future changes to Dynamic Parmeters can inherit time_fn (e.g. if a Number is changed from a float to a number generator, the number generator will inherit time_fn).

But this is not.

Complete, minimal, self-contained example code that reproduces the issue

import param
import numbergen as ng

class Foo(param.Parameterized):
    a = param.Dynamic()

print(Foo.param.a.time_fn)
    
foo = Foo()
print(foo.param.a.time_fn)

time = param.Time()
print(time)

Foo.param.set_dynamic_time_fn(time)
print(Foo.param.a.time_fn) # This has not changed

foo.param.set_dynamic_time_fn(time)
print(foo.param.a.time_fn) # This has not changed

print(Foo._Dynamic_time_fn) # This did get set
foo2 = Foo()
print(foo2.param.a.time_fn) # But was not set on the new instance parameter
foo2.a = ng.UniformRandom()
print(foo2.param.a.time_fn) # Nor set on change

<Time Time00001>
<Time Time00001>
<Time Time00003>
<Time Time00001>
<Time Time00001>
<Time Time00003>
<Time Time00001>
<Time Time00001>

Inherited child classes give weird behavior if the class name is identical to a parent class.

A simple example of this is:

import param


class Parameterized(param.Parameterized):
    number = param.Number()

    def __init__(self, **params):
        super().__init__(**params)
        self.param.number.bounds = (1, 2)


Parameterized()

Which will raise the following

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[22], line 12
      8         super().__init__(**params)
      9         self.param.number.bounds = (1, 2)
---> 12 Parameterized()

Cell In[22], line 9, in Parameterized.__init__(self, **params)
      7 def __init__(self, **params):
      8     super().__init__(**params)
----> 9     self.param.number.bounds = (1, 2)

File ~/Development/holoviz/repos/param/param/parameterized.py:1589, in Parameters.__getattr__(self_, attr)
   1586     raise AttributeError("type object '%s.param' has no attribute %r" %
   1587                          (self_.cls.__name__, attr))
   1588 else:
-> 1589     raise AttributeError("'%s.param' object has no attribute %r" %
   1590                          (self_.cls.__name__, attr))

AttributeError: 'Parameterized.param' object has no attribute 'number'

But if I rename the class to Parameterized2 everything works as expected: