Getting to the dynamic value generator of a Dynamic parameter

[jlstevens]

One thing that has frequently aggravates me about param is that there is no way (that I know of) to get at a dynamic value generator e.g a numbergen object. Perhaps there is a proper way to do this, but I have hacked in this method into my copy of param (on the Dynamic class) for the time being:

    def get_generator(self, obj):
        """
        Given a parameterized object, gets the dynamic value generator.
        """
        return super(Dynamic,self).__get__(obj, obj.__class__)

This is still awkward to use, but better than nothing. Say I have an imagen.Gaussian object and I want to fiddle the random number generator used for the orientation. Now I can do:

generator = gaussian.params('orientation').get_generator(gaussian)

Now for instance, I could change the time_fn for this numbergen object.

Any thoughts? Is there already a better way of doing this?

[ceball]

(We had an email conversation about this (my fault it was email rather than in the github issue). I'm just pasting it back here on github as a first step towards slowly dealing with it :) )

Currently, we'd use the get_value_generator method of Parameterized:

    @bothmethod
    def get_value_generator(cls_or_slf,name): # pylint: disable-msg=E0213
        """
        Return the value or value-generating object of the named
        attribute.

        For most parameters, this is simply the parameter's value
        (i.e. the same as getattr()), but Dynamic parameters have
        their value-generating object returned.
        """

(https://github.com/ioam/param/blob/master/param/parameterized.py#L1312)

For your example, it would look like this:

>>> import param,imagen,numbergen
>>> gaussian = imagen.Gaussian(orientation=numbergen.UniformRandom())
>>> gaussian.get_value_generator('orientation')
UniformRandom(lbound=0.0, name='UniformRandom00010', ubound=1.0)

You (Jean-Luc) replied with (approximately):

Why can't value_generator be accessible as an attribute or property
on the parameter? Why have these two interfaces:

# Getting a parameter
gaussian.params('orientation') 
# Getting a value generator 
gaussian.get_value_generator('orientation') 

When you could do:

gaussian.params('orientation').value_generator 

It would also be more useful to have the parameter instance
as you could access attributes (such as default, bounds etc).

I see there is a get_generator() method already which requires
a mandatory argument - I guess what I propose isn't as trivial to
implement as I would like.

[Why can't] the params() method on a Parameterized class pass
a handle (pointing to that class) to the parameters? Couldn't that
avoid the repetition and need to get a handle on the pattern generator:

# Why do I have to specify gaussian twice?
gaussian.params('orientation').get_value_generator(gaussian) 

[This way] get_value_generator() could be replaced with a property.

Note, this would just be for the convenience of the user and not
something param would need to rely on internally (as it doesn't currently).