How to Package and Deploy CLI Applications With Python

Based on the interface we have two types of applications: CLI (Command Line Interface) applications and GUI (Graphical User Interface) applications.

A command line application or console application is one which can be accessed from a shell or command line through a text interface. These accept inputs from the user in text format, unlike GUI applications which provide a graphical interface containing buttons, text boxes and icons.

Python is a popular programming language for developing CLI applications. Let's explore the complete process of packaging and deploying CLI applications with Python using built-in and external tools.

Step 1: Create a Python Package Structure

First, we need to create a proper Python package structure. A package is a directory containing an __init__.py file that indicates it's a Python package ?

my_package/
    __init__.py
    my_cli_app.py
setup.py
README.md

Here's the content for our CLI application in my_cli_app.py ?

import click

@click.command()
@click.option('--name', default='World', help='The person to greet.')
def hello(name):
    """Simple CLI application that greets users."""
    click.echo(f'Hello, {name}!')

if __name__ == '__main__':
    hello()

The __init__.py file can be empty or contain package initialization code ?

# __init__.py
__version__ = "0.1.0"

Step 2: Create the Setup Configuration

The setup.py file defines how our package should be built and installed. It specifies dependencies, entry points, and metadata ?

from setuptools import setup, find_packages

setup(
    name='my_package',
    version='0.1.0',
    description='A simple CLI application example',
    packages=find_packages(),
    install_requires=[
        'click>=7.0',
    ],
    entry_points={
        'console_scripts': [
            'my_cli_app=my_package.my_cli_app:hello',
        ],
    },
    python_requires='>=3.6',
)

Step 3: Build the Distribution Package

Now we can build our package using setuptools. First, install the build tools ?

pip install build twine

Then build the package ?

python -m build

This creates both source distribution (.tar.gz) and wheel distribution (.whl) files in the dist/ directory.

Step 4: Test Local Installation

Before publishing, test the installation locally ?

pip install dist/my_package-0.1.0-py3-none-any.whl

Test the CLI command ?

my_cli_app --name Alice

Hello, Alice!

Step 5: Deploy to PyPI

To distribute your package publicly, upload it to PyPI. First, create an account at pypi.org, then upload ?

twine upload dist/*

Users can then install your package globally ?

pip install my_package

Alternative: Using Modern Tools

For modern Python packaging, consider using pyproject.toml instead of setup.py ?

[build-system]
requires = ["setuptools>=45", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "my_package"
version = "0.1.0"
description = "A simple CLI application example"
dependencies = ["click>=7.0"]

[project.scripts]
my_cli_app = "my_package.my_cli_app:hello"

Comparison of Distribution Methods

Conclusion

Packaging CLI applications in Python involves creating a proper package structure, defining entry points, and using build tools like setuptools. The click library simplifies CLI development, while modern tools like pyproject.toml offer cleaner configuration for distribution.