Creational design patterns are the first category we will cover throughout this chapter, andChapters 2,The Builder Pattern andChapter 3,Other Creational Patterns. These patterns deal with different aspects of object creation. Their goal is to provide better alternatives for situations where direct object creation, which in Python happens within the__init__() function, is not convenient.

We will start with the first creational design pattern from theGang of Four book: the factory design pattern. In the factory design pattern, aclient (meaning client code) asks for an object without knowing where the object is coming from (that is, which class is used to generate it). The idea behind a factory is to simplify the object creation process. It is easier to track which objects are created if this is done through a central function, compared to letting a client create objects using a direct class instantiation. A factory reduces the complexity of maintaining an application by decoupling the code that creates an object from the code that uses it.

Factories typically come in two forms—thefactory method, which is a method (or simply a function for a Python developer) that returns a different object per input parameter, and theabstract factory, which is a group of factory methods used to create a family of related objects.

In this chapter, we will discuss:

• The factory method
• The abstract factory

In the software world, the Django web framework uses the factory method pattern for creating the fields of a web form. Theforms module, included in Django, supports the creation of different kinds of fields (for example,CharField,EmailField, and so on). And parts of their behavior can be customized using attributes such asmax_length orrequired (j.mp/djangofac). As an illustration, there follows a snippet that a developer could write for a form (thePersonForm form containing the fieldsname andbirth_date) as part of a Django application's UI code:

fromdjangoimportformsclass PersonForm(forms.Form):name=forms.CharField(max_length=100)birth_date=forms.DateField(required=False)

[
 {"title":"After Dark in Central Park",
  "year":1900,
  "director":null, "cast":null, "genre":null},
 {"title":"Boarding School Girls' Pajama Parade",
  "year":1900,
  "director":null, "cast":null, "genre":null},
 {"title":"Buffalo Bill's Wild West Parad",
  "year":1900,
  "director":null, "cast":null, "genre":null},
 {"title":"Caught",
  "year":1900,
  "director":null, "cast":null, "genre":null},
 {"title":"Clowns Spinning Hats",
  "year":1900,
  "director":null, "cast":null, "genre":null},
{"title":"Capture of Boer Battery by British",
  "year":1900,
  "director":"James H. White", "cast":null, "genre":"Short documentary"},
 {"title":"The Enchanted Drawing",
  "year":1900,
  "director":"J. Stuart Blackton", "cast":null,"genre":null},
 {"title":"Family Troubles",
  "year":1900,
  "director":null, "cast":null, "genre":null},
 {"title":"Feeding Sea Lions",
  "year":1900,
  "director":null, "cast":"Paul Boyton", "genre":null}
 ]

The XML file,person.xml, is based on a Wikipedia example (j.mp/wikijson), and contains information about individuals (firstName,lastName,gender, and so on) as follows:

1. We start with the enclosing tag of the persons XML container:

<persons>

2. Then, an XML element representing a person's data code is presented as follows:

<person>
  <firstName>John</firstName>
  <lastName>Smith</lastName>
  <age>25</age>
  <address>
    <streetAddress>21 2nd Street</streetAddress>
    <city>New York</city>
    <state>NY</state>
    <postalCode>10021</postalCode>
  </address>
  <phoneNumbers>
    <phoneNumber type="home">212 555-1234</phoneNumber>
    <phoneNumber type="fax">646 555-4567</phoneNumber>
  </phoneNumbers>
  <gender>
    <type>male</type>
  </gender>
</person>

3. An XML element representing another person's data is shown by the following code:

<person>
  <firstName>Jimy</firstName>
  <lastName>Liar</lastName>
  <age>19</age>
  <address>
    <streetAddress>18 2nd Street</streetAddress>
    <city>New York</city>
    <state>NY</state>
    <postalCode>10021</postalCode>
  </address>
  <phoneNumbers>
  <phoneNumber type="home">212 555-1234</phoneNumber>
  </phoneNumbers>
  <gender>
    <type>male</type>
  </gender>
</person>

4. An XML element representing a third person's data is shown by the code:

<person>
  <firstName>Patty</firstName>
  <lastName>Liar</lastName>
  <age>20</age>
  <address>
    <streetAddress>18 2nd Street</streetAddress>
    <city>New York</city>
    <state>NY</state>
    <postalCode>10021</postalCode>
  </address>
  <phoneNumbers>
    <phoneNumber type="home">212 555-1234</phoneNumber>
    <phoneNumber type="mobile">001 452-8819</phoneNumber>
  </phoneNumbers>
  <gender>
    <type>female</type>
  </gender>
</person>

5. Finally, we close the XML container:

</persons>

We will use two libraries that are part of the Python distribution for working with JSON and XML,json andxml.etree.ElementTree, as follows:

import json
import xml.etree.ElementTree as etree

TheJSONDataExtractor class parses the JSON file and has aparsed_data() method that returns all data as a dictionary (dict). The property decorator is used to makeparsed_data() appear as a normal attribute instead of a method, as follows:

class JSONDataExtractor:
  def __init__(self, filepath):
    self.data = dict()
    with open(filepath, mode='r', encoding='utf-8') as
    f:self.data = json.load(f)
    @property
    def parsed_data(self):
        return self.data

TheXMLDataExtractor class parses the XML file and has aparsed_data() method that returns all data as a list ofxml.etree.Element as follows:

class XMLDataExtractor:
  def __init__(self, filepath):
  self.tree =  etree.parse(filepath)
  @property
  def parsed_data(self):
  return self.tree

Thedataextraction_factory() function is a factory method. It returns an instance ofJSONDataExtractor orXMLDataExtractor depending on the extension of the input file path as follows:

def dataextraction_factory(filepath):
    if filepath.endswith('json'):
        extractor = JSONDataExtractor
    elif filepath.endswith('xml'):
        extractor = XMLDataExtractor
    else:
        raise ValueError('Cannot extract data from {}'.format(filepath))
    return extractor(filepath)

Theextract_data_from() function is a wrapper ofdataextraction_factory(). It adds exception handling as follows:

def extract_data_from(filepath):
    factory_obj = None
    try:
        factory_obj = dataextraction_factory(filepath)
    except ValueError as e:
        print(e)
    return factory_obj

Themain() function demonstrates how the factory method design pattern can be used. The first part makes sure that exception handling is effective, as follows:

def main():
    sqlite_factory = extract_data_from('data/person.sq3')
    print()

The next part shows how to work with the JSON files using the factory method. Based on the parsing, the title, year, director name, and genre of the movie can be shown (when the value is not empty), as follows:

json_factory = extract_data_from('data/movies.json')
json_data = json_factory.parsed_data
print(f'Found: {len(json_data)} movies')
for movie in json_data:
  print(f"Title: {movie['title']}")
  year = movie['year']
  if year:
  print(f"Year: {year}")
  director = movie['director']
  if director:
  print(f"Director: {director}")
  genre = movie['genre']
  if genre:
  print(f"Genre: {genre}")
  print()

The final part shows you how to work with the XML files using the factory method. XPath is used to find all person elements that have the last nameLiar (usingliars = xml_data.findall(f".//person[lastName='Liar']")). For each matched person, the basic name and phone number information are shown, as follows:

xml_factory = extract_data_from('data/person.xml')
xml_data = xml_factory.parsed_data
liars = xml_data.findall(f".//person[lastName='Liar']")
print(f'found: {len(liars)} persons')
for liar in liars:
    firstname = liar.find('firstName').text
    print(f'first name: {firstname}')
    lastname = liar.find('lastName').text
    print(f'last name: {lastname}')
    [print(f"phone number ({p.attrib['type']}):", p.text)
    for p in liar.find('phoneNumbers')]
    print()

Here is the summary of the implementation (you can find the code in thefactory_method.py file):

1. We start by importing the modules we need (json andElementTree).
2. We define the JSON data extractor class (JSONDataExtractor).
3. We define the XML data extractor class (XMLDataExtractor).
4. We add the factory function,dataextraction_factory(), for getting the right data extractor class.
5. We also add our wrapper for handling exceptions, theextract_data_from() function.
6. Finally, we have themain() function, followed by Python's conventional trick for calling it when invoking this file from the command line. The following are the aspects of themain function:
   • We try to extract data from an SQL file (data/person.sq3), to show how the exception is handled
   • We extract data from a JSON file and parse the result
   • We extract data from an XML file and parse the result

The following is the type of output (for the different cases) you will get by calling thepython factory_method.py command.

First, there is an exception message when trying to access an SQLite (.sq3) file:

Then, we get the following result from processing themovies file (JSON):

Finally, we get this result from processing theperson XML file to find the people whose last name isLiar:

Notice that althoughJSONDataExtractor andXMLDataExtractor have the same interfaces, what is returned byparsed_data() is not handled in a uniform way. Different Python code must be used to work with eachdata extractor. Although it would be nice to be able to use the same code for all extractors, this is not realistic for the most part, unless we use some kind of common mapping for the data, which is very often provided by external data providers. Assuming that you can use exactly the same code for handling the XML and JSON files, what changes are required to support a third format, for example, SQLite? Find an SQLite file, or create your own and try it.

In the software category, thefactory_boy (https://github.com/FactoryBoy/factory_boy) package provides an abstract factory implementation for creating Django models in tests. It is used for creating instances of models that supporttest-specific attributes. This is important because, this way, your tests become readable and you avoid sharing unnecessary code.

class Frog:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f'{self} the Frog encounters {obstacle} and {act}!'
        print(msg)

class Bug:
    def __str__(self):
        return 'a bug'

    def action(self):
        return 'eats it'

TheFrogWorld class is an abstract factory. Its main responsibilities are creating the main character and the obstacle(s) in the game. Keeping the creation methods separate and their names generic (for example,make_character() andmake_obstacle()) allows us to change the active factory (and therefore the active game) dynamically without any code changes. In a statically typed language, the abstract factory would be an abstract class/interface with empty methods, but in Python, this is not required because the types are checked at runtime (j.mp/ginstromdp). The code is as follows:

class FrogWorld:
    def __init__(self, name):
        print(self)
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Frog World -------'

    def make_character(self):
        return Frog(self.player_name)

    def make_obstacle(self):
        return Bug()

TheWizardWorld game is similar. The only difference is that the wizard battles against monsters such asorks instead of eating bugs!

Here is the definition of theWizard class, which is similar to theFrog one:

class Wizard:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f'{self} the Wizard battles against {obstacle}
        and {act}!'
        print(msg)

Then, the definition of theOrk class is as follows:

class Ork:
    def __str__(self):
        return 'an evil ork'

    def action(self):
        return 'kills it'

We also need to define theWizardWorld class, similar to theFrogWorld one that we have discussed; the obstacle, in this case, is anOrk instance:

class WizardWorld:
    def __init__(self, name):
        print(self)
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Wizard World -------'

    def make_character(self):
        return Wizard(self.player_name)

    def make_obstacle(self):
        return Ork()

TheGameEnvironment class is the main entry point of our game. It accepts the factory as an input and uses it to create the world of the game. Theplay() method initiates the interaction between the created hero and the obstacle, as follows:

class GameEnvironment:
    def __init__(self, factory):
        self.hero = factory.make_character()
        self.obstacle = factory.make_obstacle()

    def play(self):
        self.hero.interact_with(self.obstacle)

Thevalidate_age() function prompts the user to give a valid age. If the age is not valid, it returns a tuple with the first element set toFalse. If the age is fine, the first element of the tuple is set toTrue and that's the case where we actually care about the second element of the tuple, which is the age given by the user, as follows:

def validate_age(name):
    try:
        age = input(f'Welcome {name}. How old are you? ')
        age = int(age)
    except ValueError as err:
        print(f"Age {age} is invalid, please try again...")
        return (False, age)
    return (True, age)

Last but not least comes themain() function. It asks for the user's name and age, and decides which game should be played, given the age of the user, as follows:

def main():
    name = input("Hello. What's your name? ")
    valid_input = False
    while not valid_input:
        valid_input, age = validate_age(name)
    game = FrogWorld if age < 18 else WizardWorld
    environment = GameEnvironment(game(name))
    environment.play()

The summary for the implementation we just discussed (see the complete code in theabstract_factory.py file) is as follows:

1. We define theFrog andBug classes for the FrogWorld game.
2. We add theFrogWorld class, where we use ourFrog andBug classes.

3. We define theWizard andOrk classes for the WizardWorld game.
4. We add theWizardWorld class, where we use ourWizard andOrk classes.
5. We define theGameEnvironment class.
6. We add thevalidate_age() function.
7. Finally, we have themain() function, followed by the conventional trick for calling it. The following are the aspects of this function:
   • We get the user's input for name and age
   • We decide which game class to use based on the user's age
   • We instantiate the right game class, and then theGameEnvironment class
   • We call.play() on the environment object to play the game

Let's call this program using thepython abstract_factory.py command, and see some sample output.

The sample output for a teenager is as follows:

The sample output for an adult is as follows:

Try extending the game to make it more complete. You can go as far as you want; create many obstacles, many enemies, and whatever else you like.