In this post, we will learn how to “pretty print” relative dates using the dateutil library in Python. Specifically, given a relativedelta object, we will print a string that represents the number of years, months, and days that have passed between two dates.

Introduction

I am working on a project called ManagerManager that helps me keep track of the people I work for. As my team has grown, it has become important to me to have a quick reminder to celebrate milestones such as work anniversaries.

PostgreSQL age Function

PostgreSQL has a useful built-in age function that allows you to get a human readable relative date from a date or datetime column.

For example, If I was in a database somewhere, I could use the age() function to find out how old I am.

select name, birthday, age(birthday) from person;

name	birthday	age
Lev	1988-06-09	31 years 11 mons 6 days

Abstracting Away the SQL

In the first iteration of this project, I relied on “raw” SQL for all database operations. This made it easy to take advantage of the age() function in PostgreSQL. As the project became more complex, working in SQL got out of hand.

I recently switched to SQLAlchemy to make working with the database simpler. Although SQLAlchemy allows you to call out to native database functions, I didn’t want to have a hard dependency on PostgreSQL for this application, so I started to search for a quick and dirty way to do the same thing in Python.

Exploring Python datetime

My initial investigation led me to the familiar datetime module in Python. This built-in module is great for manipulating date and time objects. It includes a timedelta class which allows you to compare two datetimes at up to microseconds of resolution. This is generally useful, but unfortunately the maximum interval that this class provides is days.

import datetime

dob = datetime.date.fromisoformat('1988-06-09')
today = datetime.date.today()
today - dob

>>> datetime.timedelta(days=11662)

It turns out converting days to years, months, and weeks is much more complicated than I initially thought since you need to account for leap years and other nuances.

The dateutil Library

Luckily, the dateutil library provides several enhancements to the built-in datetime module. Most importantly for this use case, it has the relativedelta class which breaks the timedelta into years, months, days, all the way down to microseconds.

import datetime
from dateutil.relativedelta import relativedelta

relativedelta(today, dob)
dob = datetime.date.fromisoformat('1988-06-09')
today = datetime.date.today()

>>> relativedelta(years=+31, months=+11, days=+6)

The only thing missing from dateutil.relativedelta is a nice way to “pretty print” the result. For example, what if years, months, or days is equal to 0? I don’t want a string that says “0 years, 4 months, and 1 day”.

Ternary Operators to the Rescue

This was the first time that I’ve used a ternary operator in python and it actually feels like a good use case here.

def tenure(self):
    rd = relativedelta(datetime.now(), self.start_date)
    years = f'{rd.years} years, ' if rd.years > 0 else ''
    months = f'{rd.months} months, ' if rd.months > 0 else ''
    days = f'{rd.days} days' if rd.days > 0 else ''
    return f'{years}{months}{days}'

A ternary operator is a shortcut to write an if/else statement. In my opinion, it is useful for simple situations like this. Let’s break this down a little bit.

In the tenure() function described above, the code for determining years is equivalent to the following:

if years > 0:
    years = f'{rd.years} years, '
else:
    years = ''

Or, you could also write it like this:

years = ''

if years > 0:
    years = f'{rd.years} years, '

However, I think the simple one-liner ternary operator makes the entire function a bit cleaner.

Going back to the birthday example, the final output of this function unsurprisingly looks like this:

31 years, 11 months, 6 days

Conclusion

To sum things up, we can use the dateutil library coupled with your choice of if/else syntax to provide a human readable way to show the difference between two dates.

Using Docker Compose for Local WordPress development is an excellent way to get up and running with WordPress development as quickly as possible.

Benefits of Using Docker Compose for WordPress Development

Traditionally, developing WordPress locally means that you must have PHP, MySQL, and Apache (or some other web server) installed on your local workstation. The complexity of installing and configuring these tools varies by the operating system. Furthermore, you may quickly find yourself in configuration hell attempting to configure new releases of WordPress, PHP, MySQL, or Apache.

Luckily, Docker and Docker Compose remove all of the guesswork from installing, configuring, and upgrading these tools. For example, upgrading to a new version of MySQL with Docker Compose is as simple as changing a single value in a single configuration file.

FROM:
image: mysql:5.7

TO:
image: mysql:8.0

Getting Started with Docker Compose

You can start using Docker Compose for local WordPress development with four steps.

Install Docker Locally

First, make sure that you have Docker installed on your workstation. You can verify that everything is working properly by opening up a terminal and running a few commands.

Note for Windows Users

By default docker and docker-compose are not in the Windows PATH variable. For these commands to work, be sure to add C:\Program Files\Docker\Docker\resources\bin to the PATH.

Executing docker version should produce output that looks like this:

Windows Terminal
PS C:\Users\Lev Lazinskiy> docker version
Client: Docker Engine - Community
Version: 19.03.8
API version: 1.40
Go version: go1.12.17
Git commit: afacb8b
Built: Wed Mar 11 01:23:10 2020
OS/Arch: windows/amd64
Experimental: false

Server: Docker Engine - Community
Engine:
Version: 19.03.8
API version: 1.40 (minimum version 1.12)
Go version: go1.12.17
Git commit: afacb8b
Built: Wed Mar 11 01:29:16 2020
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: v1.2.13
GitCommit: 7ad184331fa3e55e52b890ea95e65ba581ae3429
runc:
Version: 1.0.0-rc10
GitCommit: dc9208a3303feef5b3839f4323d9beb36df0a9dd
docker-init:
Version: 0.18.0
GitCommit: fec3683

Executing docker-compose version should produce output that looks like this:

Windows Terminal
PS C:\Users\Lev Lazinskiy> docker-compose version
docker-compose version 1.25.4, build 8d51620a
docker-py version: 4.1.0
CPython version: 3.7.4
OpenSSL version: OpenSSL 1.1.1c 28 May 2019

Create a Project Directory Structure

Next, create an appropriate project directory structure. We’re going to mount our local project directory to a running instance of a WordPress docker container. To keep things simple, create a new directory called wordpress with the following directory structure.

PS C:\Users\Lev Lazinskiy\git\wordpress> tree
Folder PATH listing

C:.
└───wp-content
    ├───plugins
    │   └───my_new_plugin
    └───themes
        └───my_new_theme

As illustrated above, if you’re making a new plugin, the code for your plugin would go into the wordpress\plugins\my_new_plugin directory. Likewise, if you’re making a new theme, then the code for your theme would go into the wordpress\themes\my_new_theme directory.

Create a Docker Compose for Local WordPress Configuration File

The last step is to create a Docker Compose configuration file. In the wordpress directory from the previous step, create a new file called docker-compose.yml. This file should have the following contents:

version: "3"

services:

  wordpress:
    image: wordpress:latest
    restart: always
    environment:
        WORDPRESS_DB_PASSWORD: wordpress
    ports:
        - "8080:80"
    volumes:
      - "./wp-content:/var/www/html/wp-content"
    depends_on:
        - mysql

  mysql:
    image: mysql:5.7
    restart: always
    environment:
        MYSQL_ROOT_PASSWORD: wordpress
        MYSQL_DATABASE: wordpress
    ports:
        - "13306:3306"
    volumes:
        - "./mysql-data:/var/lib/mysql"

A couple of things worth highlighting in this configuration are the ports and volumes directives on the mysql container. We’re exposing port 13306 so you can use a MySQL client to connect to the running docker instance. Since we’re mounting a local volume called mysql-data any changes you make will persist across reboots.

Lastly, since we’re mounting wp-content in the wordpress container, any changes that you make to your new theme or plugin will be immediately available in your local WordPress instance.

Note for Windows Users

In order for volume mounting to work correctly on Windows, you must enable File Sharing in the Docker settings.

Open the Docker app, navigate to Resources and then File Sharing. Make sure that your primary drive is selected. Select Apply & Restart.

Run Docker Compose

You should now be able to run docker-compose up and navigate to http://localhost:8080 to see your new WordPress site running locally.

If you see the page shown above, complete the installation as you would any other WordPress site. When you log in, you will see your new theme and plugin available to install.

The first time you run Docker Compose it will take some time to download the WordPress and MySQL base images. Subsequent restarts will be quicker since Docker Compose will use a locally cached image.

Conclusion

In summary, using Docker Compose for local WordPress development is a quick and easy way to hack on WordPress themes and plugins. This approach has the added bonus of not needing to deal with the complexity of installing PHP, MySQL, or Apache on your local machine.