6 ways to package Python apps for re-use

Python's explosive growth over the last decade has shown the world it's a powerful and flexible way to accomplish very nearly anything you want to do in computing. It's also clear that Python still has a few painful shortcomings that can't be ignored.

One of Python's biggest shortcomings is that it's hard, often unreasonably so, to take a Python program you've written and just give it to someone else. Languages like C and C++, and now Go and Rust, have build tools that generate a standalone binary artifact. Python, an interpreted language, requires its runtime in order to do anything. But bundling the runtime with your code is at best a clumsy process.

Generally, you would "distribute" a Python application by giving someone the source code and telling them how to set up the Python runtime (if they don't have it already) and any dependencies for the application. There are tools you can use to generate a standalone redistributable (essentially, an artifact that can be unpacked on a system without Python and run as-is) but currently they're all third-party, ad-hoc solutions.

As of 2022, there's still no formal way to turn a Python program into a standalone item. The good news is that, depending on the task at hand and the people involved, you might be able to get away with using a more conventional method to distribute your Python applications.

This article looks at various ways to provide Python applications for others to consume. In some cases, the target user will have to install the Python runtime; in others, you can distribute the application as a standalone.

Create a pip installable package

Using pip is the most conventional and best-supported way to package a Python application for re-use. Just take your application directory and outfit it with a setup.py file, which turns it into a pip-installable package. Anyone can then launch the resulting program by adding a command to the scripts directory of their Python installation, using the entry points specification in setup.py.

You don't have to provide the package through PyPI, either. You could host it in a Git repository, and then pip install from it using the git+https://url.to.repository format (for web-hosted repos).

Use PyInstaller, py2exe, Nuitka, or another bundling solution

The most convenient way to deliver a Python application to a user is to provide them with an executable—either a single file or a directory with an easily identified executable somewhere in it. To do this, you would employ a third-party program to package the application and all its dependencies, and bundle it with a copy of the runtime.

PyInstaller is the most well-known program of this kind, and one of the best supported. It's extensible enough to allow you to bundle the data and auxiliary files, and provides a good deal of control over the resulting bundle—you can even set the icon used in the executable. Another solution, Py2exe, works similarly, although it doesn't provide some of the bundling options, such as the ability to generate a single self-unpacking executable.

A third project, Nuitka, also creates a redistributable package, but it's a more ambitious project overall. It converts a Python program and its associated libraries into a C++ executable with performance optimizations. (Currently, those optimizations are very much a work in progress.)

Yet another solution is the BeeWare suite, which developers can use to write and deploy Python applications in a cross-platform manner.

Use Zipapps or Shiv

If your program only consists of a few files with no external dependencies, you could use an application bundling system that's included with Python itself: the Zipapp standard. A directory of Python files (essentially, a module) can be packaged into a .pyz file—a .zip-format archive—and given to someone else who has the Python runtime. One click on the .pyz file, or a simple python file.pyz command, launches the application.

The big drawback of Zipapps is that it can't elegantly bundle third-party packages. To that end, the Shiv library, created by developers at LinkedIn, adds features to turn .pyz files into self-extracting archives that unpack dependencies, including binaries, into a subdirectory.

Host as a web service

If your application only needs to be accessible by way of a web interface—or if that's the only kind of access you want to grant—you can simply host the application as a web service. An application that only needs to be available locally could be hosted on your own servers, and perhaps made available through a VPN connection. A public-facing application could be hosted using an application cloud-hosting service.

If your Python application is hosted using a Jupyter notebook, it's possible to set up a public (or at least internal) server for it using JupyterHub.

Use containers

Containers (of the Docker variety) have fast become a deployment standard for server-side applications, with every major operating system building in support for them. It's no more difficult to "Dockerize" a Python application, like a web application, than it is to build a container for most any other application that uses some sort of runtime.

Create an embeddable package on Windows

Windows users have yet another option, although it involves the most heavy lifting of all. To start, you can download an embeddable package version of Python for Windows as a .zip file. This is a minimal, self-contained installation of Python that lives in a single directory, including the standard library. It's possible to place a Python application in this directory, along with its dependencies and data files. You can install the dependencies into the embeddable's directory with pip—but note that you need to use the pip from the Python installation you used to create the application, not from the embeddable package itself. (Watch a video demonstration to learn more about this concept.)