How to Humanize Delorean Datetime Objects

How to Humanize Delorean Datetime Objects


Working with datetime can be a bit daunting and challenging, and handling datetime in Python is no exception. Python's built-in datetime module introduced us to several classes - date, datetime, time, timezone and timedelta, and several external libraries have spawned to address the issues present in the official module, such as Arrow.

In this guide, we'll take a look at how to humanize datetime objects in Delorean - a library built upon pytz which is the standard library for solving problems relating to timezones, and dateutil which is used to calculate deltas between any 2 given datetime objects.

Installing Delorean Setting Up a Virtual Environment

Delorean is available for installation via pip. It is generally advisable to work in a virtual environment because it enables you to organize dependencies required by different projects isolated.

On Linux,or MacOS to create a virtual environment, we'd run:

$ python3 -m venv env
$ source env/bin/activate
$ python3 -m pip install delorean

Alternatively, on Windows we can run:

$ virtualenv env
$ .\env\Scripts\activate
$ python3 -m pip install delorean

Humanizing Delorean Datetime Objects with humanize()

While Epoch timestamps are extremely precise and great for digital devices - they're not too understandable by humans. We don't have a cognitive awareness of such scales. Additionally, we don't actually even think in dates in many cases, except for some more rare occasions. Most people might not have known what date it is, were it not for the constant clock and calendar built into most digital devices - from stationary to mobile.

For most of the time, we've been dealing with time in reference to where we are now. When did you see your friend? On the 12th of July, 2021, or yesterday? The humanize() function takes a factual date, and turns it into what people would use while conveying the time of an event:

import  delorean
datetime_strings = ["Thu July 12 2021", "June 5th, 2021", "April 28th, 2052"]

for date in datetime_strings:
    delorean_object = delorean.parse(date)
    human_date = delorean_object.humanize()

These date strings are parsed into Delorean objects and then humanized:

4 hours from now
a month ago
30 years from now

This is a great feature for annotating the time before or until events on applications. For example, you might tell a user that they've received a notification a day ago, or that a concert is coming up in a month. This can also be switched between if the event is, say, older than N days.

To do this, we'd measure if a date has occured more than N days before the current date, using timedelta and adjust the message appropriately:

import delorean
# Dates denote events, such as notifications.
# First event occured recently before writing this guide.
# The second event occured a bit over a month before that.
datetime_strings = ["Thu July 12 2021", "June 5th, 2021"]

for index, date in enumerate(datetime_strings):
    delorean_object = delorean.parse(date)
    current_time = delorean.Delorean()
    if (current_time-delorean_object) < datetime.timedelta(5):
        human_date = delorean_object.humanize()
        print(f'Event {index} happened', human_date)
        print(f'Event {index} happened on',

This results in:

Free eBook: Git Essentials

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

Event 0 happened 14 hours ago
Event 1 happened on 2021-06-05

This makes a lot of sense, because if you tell someone that something happened yesterday, there's not much thought required to make that out. But if you say that something happened a month ago, they'll likely look at the calendar to get a feel of when that was.

Humanize Relative Dates with Delorean

Delorean also makes it easy to reference dates in relation to another date in a very intuitive and humanlike way.

See you this time next Friday.

This is well understood by people, but tedious to code by hand using timedelta. Using a combination of next_ and last_ with days of the week, months or even years, we can calculate and create Delorean objects based on already existing datetimes:

from delorean import Delorean

dt_tm = Delorean()
nxt_fri = dt_tm.next_friday()
print("Friday next week: ", nxt_fri)

# Date for Two Fridays ago
two_fridays_ago = dt_tm.last_friday(2)
print("Friday two weeks ago: ", two_fridays_ago)

# Get Two Fridays from now at midnight
two_fridays_from_now_at_midnight = dt_tm.next_friday(2).midnight
print("Two Fridays from now at midnight: ", two_fridays_from_now_at_midnight)

# Get this time next month
next_month = dt_tm.next_month()
print("This time next month: ", next_month)

# Get this time next year, at midnight
next_month = dt_tm.next_year().midnight
print("This time next month: ", next_month)

To get the date of a day of the week more than just last or next week - we pass in a number denoting the number of weeks we're traversing. The same goes for days, months or years:

Friday next week:  Delorean(datetime=datetime.datetime(2021, 7, 16, 19, 25, 34, 427028), timezone='UTC')
Friday two weeks ago:  Delorean(datetime=datetime.datetime(2021, 7, 2, 19, 25, 34, 427028), timezone='UTC')
Two Fridays from now at midnight:  2021-07-23 00:00:00+00:00
This time next month:  Delorean(datetime=datetime.datetime(2021, 8, 11, 19, 25, 34, 427028), timezone='UTC')
This time next month:  2022-07-11 00:00:00+00:00


In this guide, we've taken a look at how to humanize Delorean datetime objects in Python. Humanization is the process of converting datetime instances to a more human format - using words and relative timeframes. Given the relativity of these timeframes, it makes sense to humanize dates in some cases, while not in others.

Last Updated: July 12th, 2021
Was this article helpful?

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

Geoffery, JosephAuthor

I am a software developer with interests in open source, android development (with kotlin), backend web development (with python), and data science (with python as well).


Graphs in Python - Theory and Implementation

# python# data structures# algorithms# computer science

Graphs are an extremely versatile data structure. More so than most people realize! Graphs can be used to model practically anything, given their nature of...

David Landup
Dimitrije Stamenic
Jovana Ninkovic

Data Visualization in Python: The Collatz Conjecture

# python# matplotlib# data visualization

The Collatz Conjecture is a notorious conjecture in mathematics. A conjecture is a conclusion based on existing evidence - however, a conjecture cannot be proven....

David Landup
Jovana Ninkovic

© 2013-2022 Stack Abuse. All rights reserved.