5 Python Libraries That Rescue Crashing Code

1. tqdm: Turning Debugging into Progress

When a script runs for a long time, it’s hard to know if it’s stuck. Importing tqdm adds a progress bar, letting you see exactly where execution pauses, which helps keep sanity and avoid abandoning the code.

from tqdm import tqdm
import time
for _ in tqdm(range(100)):
    time.sleep(0.05)  # simulate slow work

2. Joblib: Easy Parallelism

Copy‑pasting loops to speed up code is ineffective. joblib provides simple parallel execution with a single line of code, avoiding the complexities of threads, processes, and the GIL.

from joblib import Parallel, delayed

def square(n):
    return n * n

results = Parallel(n_jobs=4)(delayed(square)(i) for i in range(10))
print(results)

3. Pathlib: Cleaning Up File Paths

String‑based paths like "./folder//subfolder\\file.txt" become error‑prone across operating systems. Using pathlib treats paths as first‑class objects, improving readability and reliability.

from pathlib import Path
folder = Path("data") / "inputs"
for file in folder.glob("*.txt"):
    print(file.name)

4. Cachetools: Eliminating Redundant Errors

Repeated API calls can exhaust rate limits. cachetools offers a decorator‑based cache, so identical function arguments return cached results instead of hitting the server again.

from cachetools import cached, TTLCache
import requests
cache = TTLCache(maxsize=100, ttl=300)

@cached(cache)
def get_data(url):
    return requests.get(url).json()

5. Hydra: Managing Unruly Configurations

Multiple configuration files and hard‑coded constants lead to bugs. Hydra, together with OmegaConf, lets you compose and override configurations cleanly, making the codebase modular and easy to manage.

import hydra
from omegaconf import DictConfig

@hydra.main(version_base=None, config_path=".", config_name="config")
def main(cfg: DictConfig):
    print(cfg.database.url)

if __name__ == "__main__":
    main()

These libraries not only fix bugs but also shift the way projects are approached, offering incremental yet powerful improvements in automation and scalability.