Start Coding Now - python

Understanding the Template Method Pattern in Python

2024-08-24T00:00:00-07:00

Introduction

I found myself wanting to write an extensible class for handling a few fancy new APIs out there. There are a ton that do the same thing, and the field is constantly evolving, so it's useful to be able to easily switch from one to the next.

I chose the Template Method design pattern. This is useful when you have a series of steps that need to be executed in a specific order, but the implementation of some steps may vary.

What is the Template Method Pattern?

The Template Method pattern defines the skeleton of an algorithm in a base class but lets subclasses override specific steps of the algorithm without changing its structure. It's called "template method" because it defines a template for an algorithm's steps.

A Simple Example: Coffee and Tea

Let's illustrate this pattern with a simple example of brewing beverages. We'll create a base class for brewing beverages and then implement specific classes for coffee and tea.

from abc import ABC
from abc import abstractmethod


class Beverage(ABC):
    def prepare(self):
        self.boil_water()
        self.brew()
        self.pour_in_cup()
        self.add_condiments()

    def boil_water(self):
        print("Boiling water")

    def pour_in_cup(self):
        print("Pouring into cup")

    @abstractmethod
    def brew(self):
        pass

    @abstractmethod
    def add_condiments(self):
        pass


class Coffee(Beverage):
    def brew(self):
        print("Dripping coffee through filter")

    def add_condiments(self):
        print("Adding sugar and milk")


class Tea(Beverage):
    def brew(self):
        print("Steeping the tea")

    def add_condiments(self):
        print("Adding lemon")

# Usage
coffee = Coffee()
tea = Tea()

print("Making coffee:")
coffee.prepare()

print("\nMaking tea:")
tea.prepare()

In this example, Beverage is our abstract base class that defines the template method prepare(). This method outlines the steps for preparing a beverage, but leaves the implementation of brew() and add_condiments() to the subclasses.

Benefits of the Template Method Pattern

Reduce duplication by implementing the common parts of the algorithm in the base class.
Subclasses can easily override certain steps without changing the overall algorithm structure.
The base class handles the algorithm's structure, while the subclasses focus on the specific details of each step.

As long as you're clear on the data structure you want your methods to return, you can swap in many different subclasses.

Real-World Applications

The Template Method pattern is widely used in frameworks and libraries. For instance:

In web frameworks, the base controller class might define a template method for handling HTTP requests, with subclasses implementing specific behaviors for different routes.
In testing frameworks, the setup-run-teardown process is often implemented as a template method, allowing test classes to override specific parts of this process.
When calling external services, your template transforms the API response into the data structure your application is expecting.

Example Template Class

You might want to call a nutrition facts API to get info about food, but not feel locked in to a single API provider. You could write a NutritionFacts base class which outlines the get_nutrition_facts method and returns a Django NutritionInfo model object, outlining the fat, carbohydrates, and protein in a particular meal.

Then, when you're fed up (get it?) with the Spoonacular API, you can implement the Edamam API with .

Conclusion

The Template Method pattern allows for the creation of flexible and reusable code structures, making it easier to implement variations of an algorithm while keeping the overall process consistent. By understanding and applying this pattern, you can write more maintainable and extensible code in your Python projects.

Remember, while design patterns like the Template Method are useful, they should be applied judiciously. If you're only making one class, it might not be helpful to make that inherit from a base class.

Best of luck in your design endeavors.

Custom Dictionary Representation of Python Dataclass

2024-07-10T00:00:00-07:00

I've really enjoyed the shortcuts provided by Python's dataclasses.

Recently, I found myself working with an API that required camelCase keys, but I wanted to keep my Python keys in snake_case as I find it comforting.

Creating a dataclass

I created the following dataclass for working with cell locations in Google Sheets:

from dataclasses import dataclasses

@dataclass
class Coordinate:
    sheet_id: int
    row_index: int
    column_index: int

To instantiate an object:

coord = Coordinate(0, 1, 3)  # cell D2

Turning the object into a dictionary

The dataclasses.asdict() function transforms your dataclass object. It reuses your declared key names. For example:

from dataclasses import asdict

expected = {
    "sheet_id": 0,
    "row_index": 1,
    "column_index": 3
}
actual = asdict(coord)
assert(expected == actual)  # True

Making a custom dict factory

asdict() accepts an optional parameter dict_factory which is a function that tells asdict how to parse the dataclass object.

# help us transform the keys strings
def snake_case_to_camel_case(value: str) -> str:
    # split character and remove underscores
    data_list: list[str] = data.split("_")

    # capitalize the first letter of all words except the first
    for i in range(1, len(data_list)):
        data_list[i] = data_list[i][0].upper() + data_list[i][1:]
    return "".join(data_list)

# our method to plug into `asdict()`
def camel_case_dict_factory(data):
    return {snake_case_to_camel_case(field[0]): field[1] for field in data}

To use this new factory:

expected = {
    "sheetId": 0,
    "rowIndex": 1,
    "columnIndex": 3
}
actual = asdict(
    coord, dict_factory=camel_case_dict_factory
)
assert(expected == actual)  # True

For reference, here's the standard implementation of asdict().

Get Started with Python

2021-11-01T00:00:00-07:00

If you’re looking to build your Python skills, there are a bunch of resources out there. Being self-taught, I’ve gone through quite a few of them!

Here’s a list of the most memorable stuff I’ve come across, as well as an explanation of a few basic concepts that most people tend to find confusing.

Books

A book or course is the best way to begin. Tutorials are great at some point, but when you need an overview of the entire language, look for something more comprehensive.

Learn Python the Hard Way by Zed Shaw

Of all the books and such that I read, Learn Python the Hard Way was my favorite intro to Python because it has a little bit of general programming sprinkled in.

Automate the Boring Stuff with Python by Al Sweigart

Automate the Boring Stuff with Python was the first Python book I went through and it’s also good (and free to read online!).

Video Courses

You can try your luck with YouTube which usually has something great, but Real Python traditionally has the best stuff on Python. They have a ton of great, free articles, but they also have a membership that will give you access to some video courses if you prefer to learn that way. Here are two that tackle some of the most important fundamentals of Python:

And then once you can figure out pip, packages, and virtual environments, your most powerful tools are just learning all the magic that’s out there.

Useful Packages

Python Standard Library

The Python Standard Library has a bunch of stuff available to help you manipulate strings, use different data structures, and more. Doug Hellman wrote a bunch of short articles on these packages called Python Module of the Week.

Third-Party Packages

You can get similar benefits out of learning powerful third party packages (those unassociated with Python proper). Here are some examples that you would just install with `pip install package-name`:

django - a framework for building web applications
requests - helps you make web requests
black - a formatter to give you a consistent, “pythonic” code style
borb - for working with PDFs
pillow - for working with images
ffmpeg - for working with video

Projects

Lastly, make sure you get your hands dirty! You can’t truly understand how to structure a project until you build one!

Learn Python the Hard Way and Automate the Boring Stuff with Python have a bunch of projects that get you going.

If you’re feeling ambitious, try building your own project or tinkering around with someone else’s to get going!