I Published My First Python Package to PyPI — A CLI Tool for Docker Compose

I did it. I published my first package to PyPI.

It's called fast-dcp, and honestly, it started as a personal annoyance. I kept typing docker compose up --build and docker compose exec app bash dozens of times a day. My fingers got tired. So I built something about it.

What is fast-dcp?

fast-dcp is a CLI tool that provides shorthand aliases for common docker compose commands. Nothing revolutionary — just fewer keystrokes for the things you type constantly.

# Instead of this:
docker compose up --build

# Just type:
dcpu -b

# Instead of this:
docker compose exec app bash

# Just type:
dcpe app

Three commands cover the main workflows:

• dcp — general-purpose wrapper with subcommands (up, build, exec, restart, ps, logs, stop, down)
• dcpu — dedicated shorthand for docker compose up
• dcpe — dedicated shorthand for docker compose exec

Some real examples

# docker compose up -d
dcp u -d

# docker compose -f docker-compose.prod.yml up --build
dcpu -f docker-compose.prod.yml -b

# docker compose exec app bash
dcpe app

# docker compose exec app uv run pytest
dcpe app uv run pytest

# docker compose restart app
dcp r app

# docker compose logs app -f
dcp l app -F

How it's built

The implementation is pure Python — no external runtime dependencies.

The core is a DockerCmdProcessor class that builds up the docker command from parsed arguments and passes it to subprocess.run. It implements __call__, so it works naturally as a callable passed to argparse's set_defaults(func=...) — a pattern recommended in the argparse docs.

args = parser.parse_args()
code = args.func(args)
exit(code)

For the CLI definition, I wrote a small ArgDefiner wrapper around ArgumentParser to enable method chaining. It made the main() function much more declarative and readable — inspired by how Django's class-based views compose behavior through mixins.

(
    ArgDefiner(subparsers.add_parser("up", aliases=["u"], ...))
    .add_project_args()
    .add_file_args()
    .add_build_args()
    .add_detach_args()
    .add_container_name_subcmd(multiple=True)
    .set_defaults(func=Processor())
)

Testing was surprisingly clean. Unit tests cover ArgDefiner and DockerCmdProcessor independently, and integration tests use patch("sys.argv", ...) to simulate real CLI invocations end-to-end.

Install it

No external runtime dependencies — pure Python. Just install and use.

# Using pipx (recommended)
pipx install fast-dcp

# Or using uv
uv tool install fast-dcp

Not familiar with pipx or uv?

Both install CLI tools in isolated environments — no virtual environment activation needed, no conflicts with other packages. uv tool is the faster option if you already use uv.

macOS

brew install pipx
pipx ensurepath
pipx install fast-dcp

Windows

python -m pip install --user pipx
python -m pipx ensurepath
# Restart terminal, then:
pipx install fast-dcp

Linux (Ubuntu/Debian)

pip install pipx
pipx ensurepath
pipx install fast-dcp

Requirements

• Python 3.11+
• Docker with Compose V2 (docker compose, not docker-compose)

Honest thoughts on publishing for the first time

This is a small tool. It wraps a handful of docker commands and saves a few keystrokes. But getting it to a point where someone else could pipx install fast-dcp and have it just work — that took more thought than I expected.

Packaging, pyproject.toml, flit, classifiers, editable installs, importlib.metadata... there's a lot of moving parts for something that feels like it should be simple. I learned a lot just by going through the process.

If you work with docker compose regularly, give it a try. And if something is broken or missing, feel free to open an issue.

🔗 PyPI | GitHub