Pyre family example

From DANSE

Is it possible to have multiple components in an application that use the same factory name?

Yes. You have to use the 'family' keyword in the inventory. See meta-example below.

First, let's construct a "Greeter" component:

from pyre.components.Component import Component
class Greeter(Component):

    class Inventory(Component.Inventory):
        import pyre.inventory
        greeting = pyre.inventory.str("greeting",default="Hello")
        greeting.meta['tip] = "the greeting to use"

    def greet(self, friend):
        return "%s %s!" % (self.greeting, friend)

    def __init__(self, name='default-greeter'):
        Component.__init__(self, name, facility='greeter')
        self.greeting = ''
        return

    def _configure(self):
        Component._configure(self)
        self.greeting = self.inventory.greeting
        return

We can now build factories to be used from within .odb files...

"goodbye" is a 'Greeter' component (contained within a 'greeter' factory).

def greeter():
    from Greeter import Greeter
    class Goodbye(Greeter):
        def __init__(self)
            Greeter.__init__(self, "goodbye")
            return

        def _defaults(self):
            self.inventory.greeting = "Goodbye"
            return

    return Goodbye()

"farewell" is another "Greeter" component of similar construction.

def greeter():
    from Greeter import Greeter
    class Farewell(Greeter):
        def __init__(self)
            Greeter.__init__(self, "farewell")
            return

        def _defaults(self):
            self.inventory.greeting = "Farewell"
            return

    return Farewell()

To use both the 'farewell' and 'goodbye' greeters in the same pyre application, the most appropriate syntax is to use 'family'.

from pyre.applications.Script import Script
class Danse(Script):

    class Inventory(Script.Inventory):
        import pyre.inventory
        friend = pyre.inventory.str('friend', default='Tim')
        friend.meta['tip'] = "the name of the person to greet"
        friend.validator = pyre.inventory.choice(["Brent","John","Mike","Tim")]
        from Greeter import Greeter
# 1 #   greeter = pyre.inventory.facility("greeter", default=Greeter())
# 2 #   greeter = pyre.inventory.facility("greeter", factory=Greeter, args=[])
# 3 #   greeter = pyre.inventory.facility("greeter", default="goodbye")
        greeter = pyre.inventory.facility("saluter", family="greeter", default=Greeter())
        greeter.meta['tip'] = "the component that greets"

    def main(self, *args, **kwds):
        print self.greeter.greet(self.myfriend)
        return

    def __init__(self):
        Script.__init_(self, 'danse')
        self.myfriend = 'Hi'
        return

    def _configure(self):
        Script._configure(self)
        self.myfriend = self.inventory.friend
        return

if __name__='__main__':
    app = Danse()
    app.run()

Invocation methods 1, 2, and 3 (commented out above) will function well if there is only one greeter to configure. Usage for any of these cases would look like this...

$ danse.py --greeter=goodbye
 Goodbye Tim!
$ danse.py --greeter=goodbye --goodbye.greeting=Morning
 Morning Tim!
$ danse.py
 Hello Tim!

However, as soon as there are two greeters needed, you cannot refer to 'greeter' as a seperate entity! So, we must use the 'family' syntax (uncommented above). So if we added a second greeter to the Script's inventory...

        greeter2 = pyre.inventory.facility("welcomer", family="greeter", default="goodbye")

Then, we can imagine that usage would look as follows (if first the 'saluter' prints, then the 'welcomer' prints):

$ danse.py --saluter=farewell --welcomer=goodbye
 Farewell Tim!  Goodbye Tim!
$ danse.py --saluter=goodbye --saluter.greeting=Morning --welcomer=goodbye
 Morning Tim!  Goodbye Tim!
$ danse.py
 Hello Tim!  Hello Tim!