processkit

Async-and-sync child-process management for Python with a kernel-backed no-orphan guarantee: every process you start — and everything it spawns — lives in a kill-on-exit container (a Windows Job Object, a Linux cgroup v2, or a POSIX process group). Subject to the documented POSIX escape caveats, normal completion, errors, timeouts, cancellation, and context-manager exit reap descendants as a unit. Abrupt owner-death coverage is platform-specific and reported explicitly.

The deliberately named Command.spawn_detached() is the sole opt-out for a trusted helper that must outlive its launcher; it returns only a pid and carries none of the containment, waiting, timeout, or capture guarantees above.

Beyond spawning a subprocess: run-and-capture, line streaming, interactive stdin, shell-free pipelines, readiness probes, timeouts & cancellation, supervision with restart/backoff, resource-limited sandboxes, and a mockable runner seam for subprocess-free tests — each in a synchronous and an asyncio-native form.

from processkit import Command

# Require success and get trimmed stdout; a failure raises a typed exception.
version = Command("python", ["--version"]).run()
print(version)

Cover

Why processkit?

subprocess and asyncio.subprocess reach (at most) the direct child. The processes it spawned — a build tool's compiler children, the real payload behind a wrapper (cmd /c …, sh -c …), a test's helper servers — survive a timeout, an exception, or a cancelled task, and keep running as orphans.

processkit spawns every child into the operating system's own containment primitive — a Job Object on Windows, a cgroup v2 on Linux (with a process-group fallback), a POSIX process group on macOS/BSD — so teardown is a kernel operation over the whole tree, not a best-effort signal to one pid:

Nothing escapes silently. Exiting a with / async with block reaps every descendant, grandchildren included. Where a mechanism has a genuine weakness (a setsid child can escape a POSIX process group), ProcessGroup.mechanism reports the active backend instead of pretending — never a silent downgrade.
Sync and async, first-class. The run-&-capture verbs, pipelines, and supervision each exist as a plain synchronous call and an a-prefixed asyncio coroutine, sharing one set of types. The inherently-streaming surfaces — live line streaming, interactive stdin, readiness probes — are asyncio-native (awaited on a started process), not duplicated as blocking calls.
Honest results. A non-zero exit is data (ProcessResult) until you ask for success; a timeout is captured in the result; a cancellation is always an error; every platform divergence raises Unsupported or is documented. Raised exceptions carry structured fields and alias the stdlib's (Timeout is a TimeoutError, ProcessNotFound a FileNotFoundError, PermissionDenied a PermissionError).
Testable. One runner seam swaps the real spawner for scripted doubles or record/replay cassettes — no subprocess in your tests.

How it compares

	whole-tree kill-on-exit	async	sync	limits / stats	streaming · pipelines · supervision
`subprocess`	—	—	✓	—	—
`asyncio.subprocess`	—	✓	—	—	—
`processkit`	✓	✓	✓	✓	✓

The first column is the differentiator: a child's descendants are contained and reaped as a unit (Job Object / cgroup v2 / process group), not just the direct child.

Stable API. The public API has been stable since 1.0 and follows Semantic Versioning: breaking changes land only in a new major version, so 1.x upgrades are backward-compatible. See CHANGELOG.md, and ROADMAP.md for how it was built.

The hard platform work — Job Object containment, cgroup v2, race-free spawn, POSIX process groups — runs in a compiled native core, so the Python layer stays a thin, typed, asyncio-native surface with context-manager teardown.

Install

pip install processkit-py   # the import name is `processkit`

Distributed as abi3 wheels for CPython 3.10+ (one wheel per OS/arch runs on every supported minor version, 3.14 included), plus a version-specific free-threaded wheel for CPython 3.14t (PEP 703 — importing the extension does not re-enable the GIL). See the PyPI project page for released versions and files; platforms without a prebuilt wheel build from source — see below.

Picking a verb

Every run starts with the same Command builder; the verb you finish with decides what you get back. Each has an a-prefixed asyncio twin (run/arun, …):

You want	Call	You get
stdout, success required	`.run()`	trimmed `str`; non-zero exit / timeout / kill → typed exception
decoded JSON, success required	`.run_json()`	native Python value; invalid JSON → `InvalidJson`
the full outcome, exit code as data	`.output()` / `.output_bytes()`	`ProcessResult` / `BytesResult` — code, stdout, stderr, `timed_out`; never raises on a non-zero exit
just the exit code	`.exit_code()`	`int` (a timed-out / killed run raises instead of inventing `-1`)
a yes/no answer	`.probe()`	`bool` — exit 0 → `True`, 1 → `False`, anything else raises
a live handle — streaming, stdin, probes	`.start()` / `.astart()`	`RunningProcess`
a trusted helper that must outlive this process	`.spawn_detached()`	pid-only `DetachedChild`; outside containment

The run-to-completion verbs repeat on the Runner and CliClient layers too (start / astart live on Command and Runner). Deeper: Running commands.

Quick start

from processkit import Command, ProcessGroup, host_containment, process_info

# Capture output; a non-zero exit does not raise on its own.
result = Command("git", ["rev-parse", "HEAD"]).output()
print("HEAD is", result.stdout.strip(), "·", result.code)

# Require success and get trimmed stdout directly.
version = Command("python", ["--version"]).run()

# Feed stdin.
sorted_out = Command("sort").stdin_text("banana\napple\n").run()

# Share one kill-on-exit group across several children; the block exit reaps the
# whole tree, grandchildren included.
with ProcessGroup() as group:
    group.start(Command("dev-server"))
    # ... work ...
# graceful teardown on exit

The asyncio surface mirrors it with the a prefix and adds streaming:

import asyncio
from processkit import Command, ProcessGroup


async def main():
    result = await Command("git", ["rev-parse", "HEAD"]).aoutput()

    # Stream a child's stdout; the context manager reaps the tree on exit.
    async with await Command("my-build", ["--watch"]).astart() as proc:
        async for event in proc.lifecycle_events():
            print(event.kind, event.pid, event.stream, event.text, event.outcome)

    async with ProcessGroup() as group:
        await group.astart(Command("dev-server"))


asyncio.run(main())

No Python to write? python -m processkit run -- <cmd> [args...] gives a shell script or CI step the same kill-on-exit containment and resource limits from the command line, no code required. Once installed, the same wrapper is also on PATH as the shorter processkit command — both forms share the identical flag set and exit-code contract:

python -m processkit run --timeout 30 --max-memory 536870912 -- pytest -x
python -m processkit run --env-file ci.env --env MODE=test -- ./build.sh
python -m processkit run --output-limit 8388608 --stderr-file build.err -- ./build.sh
python -m processkit run --pty --pty-cols 120 --pty-rows 40 -- color-sensitive-tool
python -m processkit supervise --health-port 127.0.0.1:8080 -- ./server

# equivalent short form, once `pip install processkit-py` puts `processkit` on PATH:
processkit run --timeout 30 --max-memory 536870912 -- pytest -x

python -m processkit remains fully supported — useful when several interpreters are on the machine and the processkit command on PATH might not be the one you mean. See Command-line usage for the full flag list and exit-code contract.

Documentation

This README is the quick tour. Read the rendered documentation site for the navigable guide set, or browse its Markdown sources. The guides go deeper on every capability, with more examples and the platform fine print in one place. New here? Skim the Cookbook first — it maps "I want to …" tasks to working snippets — then read Running commands end to end:

Guide	Covers
Cookbook	Task → snippet recipes for everything below; the fastest way in
Coming from subprocess	Translating your `subprocess` / `asyncio.subprocess` code, and what containment adds
Running commands	The full `Command` builder and every consuming verb, with error semantics
Process groups	Containment, teardown, signals, suspend/resume, members, limits, stats
Sandboxing untrusted tools	A bounded agent/tool recipe and an explicit threat model
Streaming & interactive I/O	Line streaming, conversational stdin, readiness probes, per-run profiling
Pipelines	Shell-free `a \| b \| c`, pipefail attribution, chain timeouts
Timeouts & cancellation	Captured vs raised deadlines, Ctrl+C, asyncio cancellation
Supervision	Restart policies, backoff & jitter, stop conditions, outcomes
Testing your code	The runner seam, scripted/record-replay doubles, `CliClient`
Command-line usage	`run`, `supervise`, `doctor`, profiling, limits, flags, and exit codes
Performance & overhead	Benchmark scope, reproduction, and qualitative scaling expectations
Async runtimes & event loops	asyncio, uvloop, anyio compatibility, and unsupported runtimes
Platform support	Mechanisms, all capability matrices, every caveat
Troubleshooting	Symptom-first guidance for limits, signals, loops, cassettes, and teardown
API reference	Every public class, function, protocol, alias, and exception
Architecture	Python/PyO3/Rust boundaries, conventions, and drift guards

Prefer whole programs to snippets? The examples/ directory has runnable, self-contained scripts — one per niche (no-orphan teardown, a readiness-gated server, supervision, a resource-limited sandbox). Each runs on Windows, Linux, and macOS and is exercised in CI.

A tour of the capabilities

Each section below is a taste with a pointer to its full guide.

Containing a process tree

Everything started in a ProcessGroup — and everything those processes spawn — is reaped when the block exits:

from processkit import Command, ProcessGroup

with ProcessGroup() as group:
    group.start(Command("dev-server"))
    group.start(Command("worker"))
    print(group.mechanism)  # "job_object" | "cgroup_v2" | "process_group"
    print(group.soft_stop_scope)  # "whole_tree" | "opt_in_members" | "none"
    print(group.members())  # live member pids
    print(process_info(group.members()[0]))
# the whole tree, grandchildren included, is gone here

print(host_containment())  # host-wide containment capabilities

The with / async with exit (and ordinary GC) reaps the tree on every platform; surviving a hard kill of the Python process itself is a Windows-only property. Lean on the context managers, not __del__ / atexit. Deeper: Process groups · Platform support.

Sandboxing with resource limits

Bound a whole tree's memory, process count, and CPU at creation, so a runaway or untrusted child tree can't exhaust the host:

from processkit import Command, ProcessGroup

tool = (
    Command("untrusted-tool")
    .env_clear()
    .inherit_env(["PATH"])  # locked-down environment
    .cpu_affinity([0, 1])  # pin the child to selected CPUs
    .output_limit(max_bytes=8 * 1024 * 1024)
)
with ProcessGroup(max_memory=512 * 1024 * 1024, max_processes=64, cpu_quota=1.0) as group:
    group.start(tool)
    print(group.stats().active_process_count)

Limits need a Windows Job Object or a Linux cgroup-v2 root; under a container, systemd session, or other non-root cgroup the kernel forbids them and ResourceLimit is raised — never a silently-unbounded group. CPU affinity is available on Windows and Linux and raises Unsupported on other platforms. Deeper: Process groups → resource limits.

Signalling and pausing the whole tree

with ProcessGroup() as group:
    group.start(Command("my-server"))
    group.signal("hup")  # term | kill | int | hup | quit | usr1 | usr2
    group.suspend()  # freeze the whole tree…
    group.resume()  # …and let it run again

Signals are POSIX-real; on Windows only kill is deliverable (it maps to the Job Object terminate) and every other name — including term — raises Unsupported. Deeper: Process groups.

Running many at once

output_all runs a whole batch with a concurrency cap, so fanning out hundreds of commands can't exhaust file descriptors or the process table:

from processkit import Command, ProcessResult, output_all

cmds = [Command("convert", [f"{i}.png", f"{i}.jpg"]) for i in range(200)]
results = output_all(cmds, concurrency=8)  # never >8 alive at once
failed = sum(not (isinstance(r, ProcessResult) and r.is_success) for r in results)

It is collect-all: each slot is one command's ProcessResult, or a ProcessError for a spawn/I/O failure — a non-zero exit never short-circuits the batch. aoutput_all / output_all_bytes / aoutput_all_bytes round out the set. Need results as they finish instead? aoutput_as_completed (and its aoutput_as_completed_bytes twin) streams each (index, result) pair the moment its command completes, under the same concurrency cap and no-orphan teardown. Deeper: Cookbook → run many at once.

Supervising a long-lived child

A Supervisor keeps a child alive: it restarts the command per policy whenever it exits, with bounded restarts and exponential, jittered backoff:

from processkit import Command, Supervisor

outcome = Supervisor(
    Command("my-server", ["--port", "8080"]),
    restart="on_crash",  # always | on_crash | never
    max_restarts=5,
    backoff_initial=0.2,
    backoff_factor=2.0,
    max_backoff=30.0,
    stop_when=lambda r: r.code == 0,  # a clean exit ends supervision
).run()  # or: await ....arun()
print(outcome.restarts, outcome.stopped)

Deeper: Supervision.

Running a tty-sensitive CLI

Opt into a managed pseudo-terminal when a tool buffers behind pipes or requires a tty. Output is one merged terminal stream, and containment is unchanged:

with Command("interactive-tool").pty(cols=120, rows=40).keep_stdin_open().start() as proc:
    proc.resize_pty(160, 50)

The existing stdout_lines() and take_stdin() APIs work with the PTY; sanitize_vt() strips colors, cursor controls, and other terminal escapes from captured/streamed text for logging or parsing. In async code send_control("c") delivers terminal Ctrl-C semantics.

Waiting for a child to be ready

"Start a server, then use it" needs the server to be ready, not merely started. Three async probes replace the arbitrary sleep:

from processkit import Command, wait_until, wait_for_port, wait_for_line

proc = await Command("my-server").astart()
lines = proc.stderr_lines()  # use stdout_lines() when the banner is on stdout
await wait_for_line(lines, "listening on", timeout=10)  # a log line
await wait_for_port("127.0.0.1", 8080, timeout=10)  # a TCP port
await wait_until(lambda: health_check(), timeout=10, interval=0.1)  # any condition

A probe that doesn't pass in time raises WaitTimeout (ProcessError, TimeoutError) and does not kill the child — you decide what happens next. Deeper: Streaming → readiness probes.

Pipelines without a shell

a | b | c without a shell string — stages connected in-process (a relay, not a shell), so no quoting or injection surface. Each stage lives in its own kill-on-exit sub-group; chain-wide teardown still reaches every stage:

authors = (
    Command("git", ["log", "--format=%an"]) | Command("sort") | Command("uniq", ["-c"])
).run()

The outcome is pipefail: stdout is the last stage's, while the exit code, stderr, and reported program come from the first stage that didn't exit cleanly. .timeout(d) bounds the whole chain. Deeper: Pipelines.

Environment and privileges

Command("worker").inherit_env(["PATH", "HOME", "LANG"]).run()  # allow-list on a cleared env
Command("worker").gid(1000).groups([1000]).uid(
    1000
).setsid().run()  # POSIX: drop privileges, new session
Command("helper").create_no_window().run()  # Windows: no console window
Command("daemonish").kill_on_parent_death().start()  # die with a hard-killed parent

uid/gid/groups/setsid are POSIX-only — on Windows the run raises Unsupported rather than silently skipping a privilege drop. When dropping privileges, set all three of gid/groups/uid — uid alone leaves the child holding the parent's (often root's) supplementary groups. Deeper: Running commands → privileges.

Cancelling a run

A blocked sync call honors Ctrl+C (raises KeyboardInterrupt and reaps the tree). Cancelling an awaited async run — directly, or via asyncio.wait_for / asyncio.timeout — tears down the whole tree and raises asyncio.CancelledError:

import asyncio

task = asyncio.ensure_future(Command("long-job").aoutput())
task.cancel()  # the process tree is reaped; CancelledError propagates

Unlike a timeout — whose expiry is captured in the result as timed_out — cancellation is always terminal. Deeper: Timeouts & cancellation.

Async streaming and interactive stdin

The one-shot verbs buffer the whole output. For long-running or conversational children, astart() returns a live RunningProcess:

# Conversational stdin: write a request, read the response.
proc = await Command("bc").keep_stdin_open().astart()
stdin = proc.take_stdin()
await stdin.write_line("2 + 2")
print(await anext(proc.stdout_lines()))  # 4
await stdin.close()

Deeper: Streaming & interactive I/O.

Wrapping a CLI tool

Command.run_json() / arun_json() decode a one-off tool's JSON directly. CliClient binds a program to default timeout/env when repeated calls should pass only their args:

from processkit import CliClient, Command

git = CliClient("git", default_timeout=30.0)
head = git.run(["rev-parse", "HEAD"])  # or: await git.arun([...])
clean = git.probe(["diff", "--quiet"])
metadata = Command("tool", ["metadata", "--json"]).run_json()

For testable code, pass runner= (a ScriptedRunner and friends) to CliClient itself, the same way Command accepts an injected runner. Deeper: Testing your code.

Testing without spawning processes

Write your code against a runner, then inject a ScriptedRunner in tests (the test doubles live in the processkit.testing submodule):

from processkit import Command
from processkit.testing import Reply, ScriptedRunner

scripted = ScriptedRunner()
scripted.on(["git", "rev-parse"], Reply.ok("deadbeef"))
assert scripted.run(Command("git", ["rev-parse", "HEAD"])) == "deadbeef"

RecordReplayRunner captures real tool output once and replays it offline, and RecordingRunner spies on what your code ran. An opt-in deterministic scrub= callback redacts cassette arguments, cwd, stdout, and stderr before a fixture is committed while preserving replay-key symmetry. Deeper: Testing your code.

Seeing what ran (observability)

Opt in once and processkit forwards its internal run events to Python's logging — useful when a spawn or teardown misbehaves in production:

import logging
from processkit import Command, enable_logging

logging.basicConfig(level=logging.DEBUG)
enable_logging()  # idempotent; off by default

Command("git", ["rev-parse", "HEAD"]).run()
# DEBUG:processkit:child spawned program=git pid=Some(12345) mechanism=…

Records land on the processkit logger (filter it like any other); argv and env are never logged (they routinely carry secrets). Deeper: the logging recipe.

Stability

processkit follows Semantic Versioning. As of 1.0 the public API — everything re-exported from import processkit and declared in the type stubs — is stable: breaking changes land only in a new major version, so 1.x upgrades are backward-compatible. Anything underscore-prefixed is internal.

Requirements

Python 3.10 or later (abi3 wheel), including CPython 3.14 and the free-threaded (PEP 703) build 3.14t.
See platform support & caveats for per-OS behaviour and the wheel/architecture matrix.

Building from source

pip install processkit-py (the import name is processkit) covers every platform with a prebuilt wheel — see the PyPI project page for the current release. On a platform without a prebuilt wheel (32-bit targets), build from source instead (see CONTRIBUTING.md for the build prerequisites):

git clone https://github.com/ZelAnton/processkit-py
cd processkit-py
pip install .

Contributing

See CONTRIBUTING.md for build/test instructions and conventions. To report a security issue, follow SECURITY.md.

License

This project is licensed under the MIT License.

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

processkit_py-1.5.0.tar.gz (4.4 MB view details)

Uploaded Aug 8, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

processkit_py-1.5.0-cp314-cp314t-win_arm64.whl (2.0 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tWindows ARM64

processkit_py-1.5.0-cp314-cp314t-win_amd64.whl (2.1 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tWindows x86-64

processkit_py-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl (2.0 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tmusllinux: musl 1.2+ x86-64

processkit_py-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl (1.9 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tmusllinux: musl 1.2+ ARM64

processkit_py-1.5.0-cp314-cp314t-manylinux_2_28_x86_64.whl (1.9 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tmanylinux: glibc 2.28+ x86-64

processkit_py-1.5.0-cp314-cp314t-manylinux_2_28_aarch64.whl (1.8 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tmanylinux: glibc 2.28+ ARM64

processkit_py-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl (1.7 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tmacOS 11.0+ ARM64

processkit_py-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl (1.8 MB view details)

Uploaded Aug 8, 2026 CPython 3.14tmacOS 10.15+ x86-64

processkit_py-1.5.0-cp310-abi3-win_arm64.whl (2.0 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+Windows ARM64

processkit_py-1.5.0-cp310-abi3-win_amd64.whl (2.1 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+Windows x86-64

processkit_py-1.5.0-cp310-abi3-musllinux_1_2_x86_64.whl (2.0 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+musllinux: musl 1.2+ x86-64

processkit_py-1.5.0-cp310-abi3-musllinux_1_2_aarch64.whl (1.9 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+musllinux: musl 1.2+ ARM64

processkit_py-1.5.0-cp310-abi3-manylinux_2_28_x86_64.whl (1.9 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+manylinux: glibc 2.28+ x86-64

processkit_py-1.5.0-cp310-abi3-manylinux_2_28_aarch64.whl (1.8 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+manylinux: glibc 2.28+ ARM64

processkit_py-1.5.0-cp310-abi3-macosx_11_0_arm64.whl (1.7 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+macOS 11.0+ ARM64

processkit_py-1.5.0-cp310-abi3-macosx_10_12_x86_64.whl (1.8 MB view details)

Uploaded Aug 8, 2026 CPython 3.10+macOS 10.12+ x86-64

File details

Details for the file processkit_py-1.5.0.tar.gz.

File metadata

Download URL: processkit_py-1.5.0.tar.gz
Upload date: Aug 8, 2026
Size: 4.4 MB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for processkit_py-1.5.0.tar.gz
Algorithm	Hash digest
SHA256	`4c113874751cfece5ac7a76865070a7be6d99ccfbeb6216a76d248df985eea19`
MD5	`eb59ad593bea3c6a2292bb12f513e837`
BLAKE2b-256	`72d36a1cebb5395cbb3c567241e3fe69c4352f0a0cc165bb4016fd12a1a92326`

Algorithm	Hash digest
SHA256	`18328424835e72d5b8ff8d9f21a04ce791323b2176878c68463be4a67f8c3e0d`
MD5	`edfe2fe7a4dd41e074886f540d5a0246`
BLAKE2b-256	`d82cc03b0f8ec4a13b76a9536150e4a925119b456a123e5e615fc94615ae69b4`

Algorithm	Hash digest
SHA256	`6c1de0f2002205a7c5f907ada4fbaf8938c4987b12797291393d9570129af460`
MD5	`f035c6841118907015f025c7380d49c2`
BLAKE2b-256	`c139ba19dbd67862b48b8bc858b8bdb4933ccb200dd485208638fb476d036b23`

Algorithm	Hash digest
SHA256	`80bc09d023209262f9f0c93929ded1ad128daa817a27bc55421026b008165f0e`
MD5	`959d19346359bff931a7b81ba66e1801`
BLAKE2b-256	`69656e34b6e5737a87628d1376321a9411e66b696e0db3cf13d398fa6087656f`

Algorithm	Hash digest
SHA256	`5eae1c260f3a73445dbfc1e2660513f744484310b94fd1f7222d36c6b016383e`
MD5	`66fd77ccaac5cd58342ff8962ca8bfcb`
BLAKE2b-256	`5eeaa295daa7f4ab2af5d49da3f342b40189fcbb052d4e002ca86719627923d9`

Algorithm	Hash digest
SHA256	`513eb62dd6e37c66915f1d776849aa482da32b2ceeb4bc7dce9334fecea54c5d`
MD5	`b0e5f6b276e1c71b327a8e06e3a0f388`
BLAKE2b-256	`41f94dfc5e734c72ba42c952fe63293568e67ab2a867fd9ff25091be9b6d8c90`

Algorithm	Hash digest
SHA256	`604b219ef15b1fbe9bff0cf007d09a4296ae8630e54b8bb7c84108efcc90c01b`
MD5	`b00652e6d9e86901fe1a5f6300415731`
BLAKE2b-256	`5bd765adcca35070df914ee3f02bb4d3a789895ca776f5477eb6bbca00199008`

Algorithm	Hash digest
SHA256	`60bb5c5ec8939073d7f77943327af8d298a2435292059b2a90386eb71036f5f9`
MD5	`394cf54dccbb2a587ffef4b3a0f75585`
BLAKE2b-256	`01ae8ac5fdddfdde89335f5b05e0f32ec3480739c44e9ee0599734637434bc89`

Algorithm	Hash digest
SHA256	`bdd92735e61638b7e97a367b42f89a3e0119fd80ea6dd109b260b4355f2681c5`
MD5	`d98fa2d82b0c80f8a7bb2e9bfa5bdd43`
BLAKE2b-256	`e35871b6b737f5735881420e71cd628061ec92ddecb834aab48ff421ad1eee8c`

Algorithm	Hash digest
SHA256	`7899cb6d89ebf40fc09f5af40a45ddaad9e16da7c47bf7196ba7ab536a1d5a9f`
MD5	`90cf3eed0ffa50973912038f685bcf24`
BLAKE2b-256	`4b7791cdac415d6eb35cdb134ab4e523f4add1380abcbf8ec03725a1341461d8`

Algorithm	Hash digest
SHA256	`6cd6cd9b9fd89e09f5e7b9e3d6365977bf8f7333c8e504c25d8700f0dc30a07d`
MD5	`5db198beb6fb20de103aa10a53e43f54`
BLAKE2b-256	`3983bdc45b1445db880a56de67d2a155bdcb5b0d0411cc15944e706bbcad3ae2`

Algorithm	Hash digest
SHA256	`34d1ea9d9e74687fb76686eb714a2dea589868aecf5f3cd4651c0cd7f9295d5b`
MD5	`1fd16a40c4f2156a8a96a86945a61e87`
BLAKE2b-256	`eb257ad324fa57e9cbf8726927cd17c128463cf6046e4f20e539ca34838e0327`

Algorithm	Hash digest
SHA256	`ae918253e22b51ef2d21425b47c82f6a6af01ae6f732eaf09e19130f8a908529`
MD5	`79f578f7687ce48ef22914d2f015a759`
BLAKE2b-256	`31894579bf265f98501f5429b3622590d1c967e7fcbbf5571c7c816f081d75d6`

Algorithm	Hash digest
SHA256	`9d858a8d19121ab28502163ddc0132810b242f4ef1eb2b0d3311fb8b9c9a8efc`
MD5	`92d5aa7480fe99ed83c828c12f252e21`
BLAKE2b-256	`14e3dede5966098ec09998b3c69e2b603a58706443324e3bffb62e845df9650d`

Algorithm	Hash digest
SHA256	`66005ea7e189dbec88d46e6b33d011cc81a7143a0bf6dcef8498d079aeece37f`
MD5	`9c83830733da60d660c93338e9b139ba`
BLAKE2b-256	`32664fa38b4cdf0e2462e8714b53cdcdc90d0244bafe6493de9821c6165c9f0c`

Algorithm	Hash digest
SHA256	`100b553cca7b05b418b2dbd00a53cad681cf8c2ae033c83ed52e3bdb9380d2d3`
MD5	`7d8d49eebac970759b39a1fe372f80b4`
BLAKE2b-256	`b1977d5acd2229f63b215a6d8ae5af5b7e446c90638896bd6eff2601fa56bfb6`

Algorithm	Hash digest
SHA256	`f38ff2fd43ddb9a619dd78547a29dd4f2c0a56e405f414931faace9e6195d1e6`
MD5	`54dc4da609cc5597c04588107b6017f4`
BLAKE2b-256	`3888845e2334e0741ab3c7ad15c238ceb5a52c2c0a98088663b1543c4de8c890`

processkit-py 1.5.0

processkit

Why processkit?

How it compares

Install

Picking a verb

Quick start

Documentation

A tour of the capabilities

Containing a process tree

Sandboxing with resource limits

Signalling and pausing the whole tree

Running many at once

Supervising a long-lived child

Running a tty-sensitive CLI

Waiting for a child to be ready

Pipelines without a shell

Environment and privileges

Cancelling a run

Async streaming and interactive stdin

Wrapping a CLI tool

Testing without spawning processes

Seeing what ran (observability)

Stability

Requirements

Building from source

Contributing

License

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License expression

Requires

Tags

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance