Maintenance free Factory design pattern (Python recipe) by Akira Fora

ActiveState Code (http://code.activestate.com/recipes/576687/)

'containsIngredient' should be a static method

You're right. Recipe updated. Thanks.

I'm baffled. Why would you charge me 11.50 for curry without pineapple?

self isn't used in newPizza method of PizzaFactory class. Just write newPizza as a function and call it.

Where you have written

if ingredient in ingredientList:
    return True
else:
    return False

instead just write

return ingredient in ingredientList

There's a terrible amount of duplicated code. Let's change the containsIngredient method to __contains__. Now we can exploit the python syntax and write "if ingredient in pizza:" where you had had "if pizza.contains(ingredient):". Next, discard the static methods, install some class dependent informations, and rewrite the base Pizza class. The following python3 program produces the same output, but I still don't get it. Merci.

TypeType = type(type)

class Pizza:

    ingredientList = []
    price = 0.00

    def __contains__(self,ingredient):
        return ingredient in self.ingredientList

    def getPrice(self):
        return self.price

class PizzaHamAndMushroom(Pizza):
    ingredientList = ["ham", "mushroom"]
    price = 8.50

class PizzaHawaiian(Pizza):
    ingredientList = ["pineapple", "curry"]
    price = 11.50

def newPizza(ingredient):
    # Walk through all Pizza classes 
    pizzaClasses = [j for (i,j) in globals().items() if isinstance(j, TypeType) and issubclass(j, Pizza)]
    for pizzaClass in pizzaClasses :
        pizza = pizzaClass()
        if ingredient in pizza:
            return pizza
    #if research was unsuccessful, raise an error
    raise ValueError('No pizza containing "%s".' % ingredient)

def main():
    myPizza = newPizza("ham")
    print(myPizza.getPrice())
    myPizza2 = newPizza("curry")
    print(myPizza2.getPrice())
    myPizza3 = newPizza("beef")

if __name__ == "__main__":
    main()

I updated the implementation of containsIngredient(). As for your other points : The rule used by the factory to choose the subclass depends entirely on your needs. In this recipe, the rule is ‘make a pizza that contains the desired ingredient’. Using __contains__ seems right in this very example, but real use cases of the factory pattern are rarely as simple as this recipe. For instance, you may need a factory that asks to all the subclasses how they perform in a given situation and selects the best performer. Same objection for the rewrite of the base class : real specialized subclasses usually do more than provide a mere constant.

Thank you. and, Ah! The essence of the recipe is

scan global dictionary for best fit class. return it or raise an error.

(your code returns the object; my constructors often need arguments.)

I suppose I'll vote +1 for the recipe. I'd never have thought of it, probably because I write deterministic code. That is, if I need a new class variant at run time I build it at run time and therefor know its features. Your code is a good reminder that one can often "go kilometers" by tinkering with the various dictionaries python builds to hold name spaces.

I can see how this design will introduce problems in the future? For example, you keep adding pizzas (ie, Pepperoni Pizza, Meat Lovers Pizza) you're ingredient list for each would be:

["pepperoni"]

and

["ham", "pepperoni", "chicken"]

So looping through the ingredient list with "ham" might get you either a Meat Lover's Pizza or Ham and Mushroom. If you loop through with "pepperoni", you might get either Pepperoni Pizza or Meat Lovers Pizza. I don't see this as a very robust design. It's bound to create problems in the future.

Please excuse my horrible grammar and spelling errors.

Hi Chris. Please read my earlier comment. Again, this recipe is not about whether it is clever to pick the first pizza that contains a given ingredient. It is about adding new pizzas without updating the rest of your code. A good real-life use case would be adding codecs to an image viewer. Pizzas would be codecs, ingredients would be filename extensions, getPrice() method would be render() method.

including a try except in main method makes sure the uninitiated does not get a traceback when you copy and run the recipe

def main():
try:
    myPizza = PizzaFactory().newPizza("ham")
    print(myPizza.getPrice())
    myPizza2 = PizzaFactory().newPizza("curry")
    print(myPizza2.getPrice())
    myPizza3 = PizzaFactory().newPizza("beef")
except ValueError as ve:
    print ve

Rather than rummaging through all the entire globals() namespace looking for Pizza subclasses you could find all its direct subclasses with simply:

    for pizzaClass in Pizza.__subclasses__():
        . . .

However to get all descendants a recursive function like the following would be needed (adapted from this answer & my comments to the question How can I find all subclasses of a given class in Python? on stackoverflow):

def all_subclasses(classname):
    subclasses = eval(classname).__subclasses__()
    return subclasses + [g for s in subclasses
                            for g in all_subclasses(s.__name__)]

and used instead like so:

    for pizzaClass in all_subclasses('Pizza'):
        . . .