A stdout Progress Bar Without a Library (Python)
tqdm is wonderful but adds 30k of dependencies for a 30-line job. Here is the pure-stdlib progress bar I drop into ETL scripts when I just want to know how far through the file I am.
By @rajtanaka
March 31, 2026
·
Updated May 20, 2026
359 views
8
Rate
from __future__ import annotations
import sys
import time
# A bar that fits in 30 lines and never lies. Width 40 columns; ETA computed
# from the average rate over the whole run so a slow start does not make the
# end-of-run ETA wildly optimistic.
def bar(total, width=40):
start = time.perf_counter()
last_render = 0.0
isatty = sys.stdout.isatty()
def render(i):
nonlocal last_render
now = time.perf_counter()
if isatty and (now - last_render) < 0.05 and i != total:
return
last_render = now
frac = i / total if total > 0 else 1.0
filled = int(frac * width)
elapsed = now - start
rate = i / elapsed if elapsed > 0 else 0
eta = (total - i) / rate if rate > 0 else 0
line = f'[{"#" * filled}{"." * (width - filled)}] {i}/{total} rate={rate:5.0f}/s eta={eta:5.1f}s'
if isatty:
print('\r' + line, end='', flush=True)
else:
print(line, flush=True)
if i == total and isatty:
print()
return render
N = 50
render = bar(N)
for i in range(1, N + 1):
time.sleep(0.005) # pretend work
render(i)Three small choices keep this honest. The redraw throttle (0.05s) means the bar updates at 20fps regardless of how fast the loop is, so a hot loop does not pay a syscall on every iteration. The TTY check makes the bar collapse into a flat print when output is piped to a file, so log files stay readable. The rate calculation uses elapsed-since-start rather than a windowed estimate, which is slower to react but never produces a 'eta=0.1s' lie when the loop has been running for an hour. I have shipped this in two ETL scripts; the first time anyone needs more (multi-bar, nested progress, byte-rate units) I switch to tqdm and stop pretending.
from __future__ import annotations
import sys
import time
from typing import Iterable, Iterator, TypeVar
T = TypeVar('T')
# Make it composable: track(rows) yields each row and updates the bar.
# Pattern matches tqdm's API so callers can swap implementations later.
def track(iterable, total=None, width=40, label=''):
if total is None:
try:
total = len(iterable)
except TypeError:
iterable = list(iterable)
total = len(iterable)
start = time.perf_counter()
last_render = 0.0
isatty = sys.stdout.isatty()
def render(i):
nonlocal last_render
now = time.perf_counter()
if isatty and (now - last_render) < 0.05 and i != total:
return
last_render = now
frac = i / total if total > 0 else 1.0
filled = int(frac * width)
rate = i / (now - start) if (now - start) > 0 else 0
line = f'{label}[{"#" * filled}{"." * (width - filled)}] {i}/{total} rate={rate:5.0f}/s'
if isatty:
print('\r' + line, end='', flush=True)
else:
print(line, flush=True)
if i == total and isatty:
print()
for i, item in enumerate(iterable, start=1):
yield item
render(i)
rows = list(range(40))
for row in track(rows, label='processing '):
time.sleep(0.005)
_ = row * 2The generator wrapper is what makes this a drop-in for any for x in items loop: replace items with track(items) and you get progress for free. The total parameter is needed because some iterables (generators, infinite sequences) have no __len__; for those you either pass total=N from the caller or fall back to materializing the full iterable, which the snippet does only when the caller does not supply total. Matching tqdm's API name and signature is deliberate: when the project grows up and we install tqdm, every call site that uses track(...) switches by changing one import line. I have done that migration twice and it took three minutes each time.
from __future__ import annotations
import sys
import time
import io
# The bar makes more sense in bytes when you are reading a 5GB file.
# Format the rate in MB/s; format the totals in human units so the line reads.
def human_bytes(n):
units = ['B', 'KB', 'MB', 'GB', 'TB']
i = 0
f = float(n)
while f >= 1024 and i < len(units) - 1:
f /= 1024
i += 1
return f'{f:6.1f} {units[i]}'
def byte_bar(total_bytes, width=40):
start = time.perf_counter()
last_render = 0.0
isatty = sys.stdout.isatty()
def render(read_bytes):
nonlocal last_render
now = time.perf_counter()
if isatty and (now - last_render) < 0.05 and read_bytes != total_bytes:
return
last_render = now
frac = read_bytes / total_bytes if total_bytes > 0 else 1.0
filled = int(frac * width)
elapsed = now - start
rate = read_bytes / elapsed if elapsed > 0 else 0
line = (
f'[{"#" * filled}{"." * (width - filled)}] '
f'{human_bytes(read_bytes)} / {human_bytes(total_bytes)} '
f'{human_bytes(rate)}/s'
)
if isatty:
print('\r' + line, end='', flush=True)
else:
print(line, flush=True)
if read_bytes == total_bytes and isatty:
print()
return render
TOTAL = 1 * 1024 * 1024
CHUNK = 32 * 1024
fake_source = io.BytesIO(b'x' * TOTAL)
render = byte_bar(TOTAL)
read = 0
while True:
chunk = fake_source.read(CHUNK)
if not chunk:
break
read += len(chunk)
time.sleep(0.0005)
render(read)The bytes variant is the same shape with one swap: the human-readable formatter for sizes and rates. human_bytes walks the unit ladder until the value is below 1024, which is the cleanest pure-stdlib equivalent of humanize.naturalsize and avoids the dependency. The throttle still applies; flushing 100 times per second on a fast SSD copy is otherwise where you spend a measurable fraction of the wall-clock time. The TTY branch matters even more here because file-copy scripts are the ones most often piped to a log file; without it your nightly backup log fills with terminal escape codes.