import subprocess

def git_rev(path: str) -> str:
    result = subprocess.run(
        ["/usr/bin/git", "-C", path, "rev-parse", "HEAD"],
        stdin=subprocess.DEVNULL,
        capture_output=True,
        text=True,
        encoding="utf-8",
        errors="replace",
        timeout=30,
        check=True,
    )
    return result.stdout.strip()

import os
import signal
import subprocess

def run_tree(argv: list[str], *, timeout: float, grace: float = 5.0) -> int:
    # start_new_session=True puts the child in its own session, so its process
    # group id equals its pid: one killpg stops the child and every descendant.
    proc = subprocess.Popen(argv, start_new_session=True, stdin=subprocess.DEVNULL)
    try:
        return proc.wait(timeout=timeout)
    except subprocess.TimeoutExpired:
        os.killpg(proc.pid, signal.SIGTERM)      # ask the whole group to stop
        try:
            proc.wait(timeout=grace)             # give it a moment to exit cleanly
        except subprocess.TimeoutExpired:
            os.killpg(proc.pid, signal.SIGKILL)  # then stop asking
            proc.wait()                          # always reap
        raise

from concurrent.futures import ThreadPoolExecutor
import subprocess

def run_all(argv_list: list[list[str]], *, max_parallel: int = 8) -> list[str]:
    def one(argv: list[str]) -> str:
        done = subprocess.run(
            argv, capture_output=True, text=True, encoding="utf-8",
            timeout=60, check=True,
        )
        return done.stdout

    # max_workers bounds how many children exist at once. Same principle as
    # async-bound-concurrency, applied to processes instead of coroutines.
    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        return list(executor.map(one, argv_list))

from concurrent.futures import ThreadPoolExecutor

def handle(item: str) -> None: ...

with ThreadPoolExecutor(max_workers=4) as executor:   # shutdown(wait=True) on exit
    futures = [executor.submit(handle, item) for item in items]
    for future in futures:
        future.result()   # never let a worker's exception disappear

import multiprocessing
from concurrent.futures import ProcessPoolExecutor

_conn = None                      # assigned once per worker by init_worker()

def init_worker(dsn: str) -> None:
    global _conn
    _conn = connect(dsn)          # opened once per worker process, not once per task

def score(row_id: int) -> float:
    return _conn.query(row_id)    # must be importable at module top level to be picklable

if __name__ == "__main__":        # required by the spawn and forkserver start methods
    ctx = multiprocessing.get_context("spawn")   # name it; never inherit the default blindly
    with ProcessPoolExecutor(max_workers=8, mp_context=ctx,
                             initializer=init_worker, initargs=(dsn,)) as executor:
        results = list(executor.map(score, row_ids, chunksize=200))