How I stopped re-resolving dependencies without rewriting pip

Jonas G Mwambimbi — Thu, 11 Jun 2026 17:02:39 +0000

I got tired of watching pip think for at least 45 seconds before I could write a single line of code only to get back to waiting for dependency resolution and/or installation, so I built a hack that remembers the answer.

What was the issue really?

I built a plug-and-play FastAPI engine ChaCC‑API that loads modules with their own requirements.txt. With every restart, it re‑resolved every module's dependencies. Like running pip install over and over.

In development, with a medium‑sized module, that meant 45 seconds of waiting. Even when nothing changed.

Restart server? Wait. Edit a module? Wait. Add a module? Wait again.

Then this happened:

I built chacc-dependency-manager. It does one smart thing though very small :)

Cache the result of pip-compile.

cache_key = hash(requirements + python_version + os)
if cache_key in cache:
    pinned = cache[cache_key]           # use saved answer
else:
    pinned = run_pip_compile()          # solve once (slow)
    cache[cache_key] = pinned

# Only install what's actually missing
install_missing_packages(pinned)

No extra resolver runs. No unnecessary pip install calls. Just remember the plan, then do only what's needed.

Does it work?

First run (or after requirements change): ~45 seconds (resolve + install)
Cache hit (no changes): <2 seconds (skip resolution, install only missing packages – usually nothing)

In my dev workflow, that 45‑second wait on every restart is now gone when dependencies are stable.

But be real: If you're actively editing requirements.txt, you'll pay the price if not worse each time you change it. This hack shines when you're not changing dependencies often, exactly my case.

What it won't do

Resolve conflicts – still uses pip-compile for that.
Make cold installs faster – first run is full price.
Beat uv in a speed contest - if you're starting fresh, just use uv. It's faster and smarter.
Warn you about version conflicts across modules – those will still surface at install time.

It's a tiny caching wrapper for a specific modular workflow. That's it.

Try it if you're tired of waiting

Standalone or try and use ChaCC‑API (toggle ENABLE_PLUGIN_DEPENDENCY_RESOLUTION) to see it in action.

🔗 GitHub

🔗 PyPI

What's your "I just want to cache this" story?

#buildinpublic #pip

Building ChaCC-API: A personal journey from 2023 to today

Jonas G Mwambimbi — Fri, 13 Mar 2026 08:15:29 +0000

I'm excited to share a project that's been years in the making—ChaCC-API

It's an open-source engine built with FastAPI that lets you run multiple modules without reinventing the setup every time. Think of it as a lightweight, modular backend that handles the heavy lifting so you can focus on building.

What it does:

Provides a plug-and-play architecture for Python modules
Comes with a dependency helper (chacc-dependency-manager) that accelerates pip installations
Packaged for easy install via PyPI and Docker
Born from a personal need to stop repeating myself

I'd love for you to check it out, star the repo if it interests you, or even contribute—whether it's code, ideas, or just letting me know how you might use it. Open source thrives on community, and this project is just getting started.

Let me share journey behind it...

I’ve always been fascinated by how software installations work. There was something almost magical about the idea that I could create something people could use, something tangible that would actually bring value to a community. But for a long time, that felt out of reach—too complex, too far beyond my skills.

It started in 2023. I opened my editor and began a Django project. I had grand ideas, but I was also overwhelmed, inexperienced, and easily distracted. The code sat there, mostly untouched, for months.

Then, around July 2025, something clicked. Maybe it was the extra time, maybe it was the confidence I’d gained from other projects, or maybe it was the fact that AI tools had made experimentation so much faster. I picked up that old repo and started over—this time with FastAPI.

I wanted to build a single app, but soon a question crept in: Why should each app be siloed? Why can’t I build an engine that runs installable modules, so I never have to repeat the same setup and functionalities again? That question sparked the core idea behind ChaCC-API.

Inspired by tools like VMan which I am part of developers and OpenMRS, I decided to build something for me, a way to package and share modules without reinventing the wheel every time. Along the way, I hit a few snags that led me to create a small helper library: chacc-dependency-manager. It’s really just a pip accelerator, not a full-blown dependency manager, but it solved the immediate problem and taught me a lot about packaging.

Now, here we are. ChaCC-API is live—new, not yet battle‑tested, and paired with a single module that’s still under active development. But it works and I’m proud of that.

The screenshot below shows part of the commit history—you can see the long gap, then the burst of activity since last year. Every commit represents a small win, a moment of clarity, or a bug I finally understood. With help of AI tools, I have learned and done a lot that would've taken me years of back and forth.

If you’re curious, resources are here:

This isn’t a product announcement, it’s just me saying: I built something I always wondered about, and that feels really good.

If you try it out, have ideas, or want to contribute in anyway, I'd genuinely love to hear from you. Let's build something together.

#personalachievement #opensource #fastapi #python #learningjourney