gipper 0.3.0__py3-none-any.whl

gipper/market.py

@@ -0,0 +1,179 @@
+"""Shopping across providers: every market answers with the same Offer, and one
+ranking decides: the job's GPU preference first, then the whole-run score from
+gipper.costs (expected dollars, the chance of a bad host, time), then known stock.
+
+GPU names differ by provider ("NVIDIA GeForce RTX 4090", "RTX 4090", "RTX4090"),
+so preferences match on a normalised name. Regions are ISO country codes ("US",
+"CA"); each provider maps its own locations onto them.
+"""
+import re
+from dataclasses import dataclass, field
+
+from gipper.config import settings
+
+
+@dataclass
+class Offer:
+    provider: str
+    gpu: str                 # the provider's own name for the GPU
+    mem_gb: float
+    usd_h: float
+    where: str = ""          # the provider's location ("EUR-IS-2", "Michigan, US", "desmoines-usa-1")
+    country: str | None = None
+    stock: str | None = None  # High/Medium/Low, "yes" for a specific machine, None if unknown
+    udp: bool = False        # can expose UDP ports
+    ref: dict = field(default_factory=dict)  # what the provider needs to rent it
+    metrics: dict = field(default_factory=dict)   # what the provider advertises (speeds, fees, CUDA); missing stays missing
+    estimate: dict = field(default_factory=dict)  # gipper.costs.estimate for the job being shopped
+
+    @property
+    def label(self):
+        return f"{self.provider}:{self.gpu}"
+
+    @property
+    def placement_estimate(self):
+        """0.1's name for `estimate`."""
+        return self.estimate
+
+
+_NOISE = re.compile(r"nvidia|geforce|generation|pcie|sxm\d?|[^a-z0-9]")
+
+
+def norm(name):
+    """'NVIDIA GeForce RTX 4090' -> 'rtx4090' -> '4090'; 'RTX6000Ada' -> '6000ada'."""
+    n = re.sub(r"(\d)gb\b", r"\1g", name.lower())   # "A100 80GB" and "A100_80G" are one card
+    n = _NOISE.sub("", n)
+    return n[3:] if n.startswith("rtx") and len(n) > 3 else n
+
+
+def matches(pref, gpu):
+    """Same card, or the same card with a memory size ("A100" matches "A100 80GB");
+    a variant is another card ("4090" does not match "4090D", "L40" not "L40S")."""
+    p, g = norm(pref), norm(gpu)
+    return bool(p) and (g == p or (g.startswith(p) and g[len(p)].isdigit()))
+
+
+def wants_udp(ports):
+    return any(p.lower().endswith("/udp") for p in ports)
+
+
+def admit(offers, *, min_mem_gb=0, regions=(), ports=(), placement=None):
+    """Drop what can't serve the job: too little memory, outside its regions, no UDP,
+    or below a [placement] floor the provider advertises. A floor on a figure the
+    provider doesn't advertise passes here and is checked on the machine itself."""
+    regions = {r.upper() for r in regions}
+    from gipper.placement import distance_km, rtt_ms
+    floors = [] if placement is None else [
+        ("host_download_mbps", placement.min_host_download_mbps), ("host_upload_mbps", placement.min_host_upload_mbps),
+        ("cuda_max_good", placement.min_cuda), ("compute_capability", placement.min_compute_capability),
+        ("dlperf", placement.min_dlperf)]
+    out = []
+    for o in offers:
+        if o.mem_gb < min_mem_gb:
+            continue
+        if regions and (o.country or "").upper() not in regions:
+            continue
+        if wants_udp(ports) and not o.udp:
+            continue
+        if any(floor is not None and o.metrics.get(k) is not None and o.metrics[k] < floor for k, floor in floors):
+            continue
+        if placement is not None and placement.max_rtt_ms is not None:   # a limit on what wasn't measured fails
+            rtt = rtt_ms(o, placement)
+            if rtt is None or rtt > placement.max_rtt_ms:
+                continue
+        if placement is not None and placement.max_distance_km is not None:
+            km = distance_km(o, placement)
+            if km is None or km > placement.max_distance_km:
+                continue
+        out.append(o)
+    return out
+
+
+def rank(offers, prefer=(), providers=(), *, job=None, history=None, throughput=None):
+    """Preferred GPUs first (in the job's order), then offers known to be in stock
+    (Runpod's types without stock mostly fail to rent), then the lowest whole-run
+    score (needs the job), then the provider order in settings."""
+    def pref_rank(o):
+        return next((i for i, p in enumerate(prefer) if matches(p, o.gpu)), len(prefer))
+    prov = {p: i for i, p in enumerate(providers)}
+    if job is not None:
+        from gipper.costs import estimate
+        from gipper.history import History
+        history = history or History.load()
+        for o in offers:
+            o.estimate = estimate(job, o, history, throughput=throughput)
+    if job is not None and job.placement.objective == "latency":
+        from gipper.placement import distance_km
+        p = job.placement
+
+
+        def near(o):   # best round-trip figure, then preferred country, then distance
+            rtt = o.estimate.get("rtt_ms")
+            country = p.preferred_countries.index(o.country) if o.country in p.preferred_countries else len(p.preferred_countries)
+            km = distance_km(o, p)
+            return (rtt is None, rtt if rtt is not None else 0, country, km if km is not None else float("inf"))
+        return sorted(offers, key=lambda o: (pref_rank(o), o.stock is None, *near(o), o.estimate.get("score", o.usd_h),
+                                             prov.get(o.provider, len(prov))))
+    return sorted(offers, key=lambda o: (pref_rank(o), o.stock is None, o.estimate.get("score", o.usd_h),
+                                         prov.get(o.provider, len(prov))))
+
+
+def ceiling(offers, job_max=None, prefer=()):
+    """0.1's hourly ceiling (2x the cheapest stocked preferred offer); kept for callers
+    that print it. Ranking no longer needs it: the score already prices the run."""
+    if job_max:
+        return job_max
+    pool = [o for o in offers if any(matches(p, o.gpu) for p in prefer)] or offers
+    stocked = [o.usd_h for o in pool if o.stock] or [o.usd_h for o in pool]
+    return 2 * min(stocked) if stocked else 0
+
+
+def shop(job, *, names=None, keyed_only=True, history=None, throughput=None):
+    """Offers that can serve the job from every usable provider, ranked, plus notes on
+    providers that were skipped or failed (one market being down never stops another)."""
+    from gipper.providers import load
+    s = settings()
+    names = names or job.providers or s["providers"]
+    if job.volume:  # network volumes are Runpod's
+        names = [n for n in names if n == "runpod"]
+    offers, notes = [], []
+    for name in names:
+        try:
+            p = load(name)
+        except KeyError as e:
+            notes.append(str(e))
+            continue
+        if keyed_only and not p.has_key():
+            notes.append(f"{name}: no {p.key_name}; skipped")
+            continue
+        if wants_udp(job.ports) and not p.udp:
+            notes.append(f"{name}: no UDP; skipped")
+            continue
+        try:
+            offers += p.offers(job)
+        except (Exception, SystemExit) as e:  # one market's outage (or missing key) must not stop the others
+            notes.append(f"{name}: {e}")
+    if job.placement.probe_rtt:
+        notes += probe_rtt(admit(offers, min_mem_gb=job.min_mem_gb, regions=job.regions, ports=job.ports))
+    offers = admit(offers, min_mem_gb=job.min_mem_gb, regions=job.regions, ports=job.ports, placement=job.placement)
+    return rank(offers, job.prefer, names, job=job, history=history, throughput=throughput), notes
+
+
+PROBE_LIMIT = 48   # hosts pinged per shop, cheapest first
+
+
+def probe_rtt(offers):
+    """Ping the cheapest offers' hosts from here before renting, into
+    metrics["rtt_ms_here"], and remember the readings (a `market.rtt` receipt)."""
+    from gipper import ledger
+    from gipper.latency import HERE, ping_all
+    pick = sorted((o for o in offers if o.metrics.get("public_ip")), key=lambda o: o.usd_h)[:PROBE_LIMIT]
+    if not pick:
+        return []
+    found = ping_all(o.metrics["public_ip"] for o in pick)
+    for o in pick:
+        o.metrics["rtt_ms_here"] = found.get(o.metrics["public_ip"])
+    samples = [{"provider": o.provider, "machine": o.ref.get("machine"), "country": o.country,
+                "ms": o.metrics["rtt_ms_here"]} for o in pick if o.metrics["rtt_ms_here"] is not None]
+    ledger.write("market.rtt", {"origin": HERE, "samples": samples})
+    return [f"pinged {len(pick)} host(s) from {HERE}: {len(samples)} answered"]

gipper/network_probe.py

@@ -0,0 +1,78 @@
+"""Small opt-in private SSH transfer probe; no public speed-test endpoint.
+
+subprocess.run owns, kills and waits for its SSH child on timeout. No pipeline
+children are created. Timings include SSH setup, encryption and local disk I/O;
+these are path goodput observations, never RTT measurements.
+"""
+import hashlib
+import os
+import shlex
+import socket
+import subprocess
+import tempfile
+import time
+import uuid
+from pathlib import Path
+
+
+def probe(remote, profile):
+    size = int(profile.probe_transfer_mb * 1024**2)  # configuration MB is explicitly MiB
+    start = time.monotonic()
+    deadline = start + profile.probe_timeout_s
+    cleanup_reserve = min(3.0, profile.probe_timeout_s / 4)
+    remote_path = '/tmp/gipper-network-probe-' + uuid.uuid4().hex
+    quoted = shlex.quote(remote_path)
+    receipt = {'origin_hostname': socket.gethostname(), 'destination_host': remote.host,
+               'destination_port': remote.port, 'bytes_per_direction': size,
+               'basis': 'random private bytes over Remote SSH; wall goodput includes SSH overhead, not RTT',
+               'status': 'error', 'upload_mbps': None, 'download_mbps': None,
+               'min_upload_mbps': profile.min_measured_upload_mbps,
+               'min_download_mbps': profile.min_measured_download_mbps}
+    def remaining():
+        value = deadline - time.monotonic() - cleanup_reserve
+        if value <= 0:
+            raise subprocess.TimeoutExpired('network probe', profile.probe_timeout_s)
+        return value
+    try:
+        with tempfile.TemporaryDirectory(prefix='gipper-network-probe-') as directory:
+            native, returned = Path(directory)/'random', Path(directory)/'returned'
+            native.write_bytes(os.urandom(size))
+            with native.open('rb') as src:
+                t = time.monotonic()
+                result = subprocess.run(remote._base() + [f"umask 077; trap 'rm -f {quoted}' HUP INT TERM; cat > {quoted}"],
+                                        stdin=src, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=remaining())
+                elapsed = time.monotonic() - t
+            if result.returncode:
+                raise RuntimeError('probe upload SSH failed')
+            receipt.update(upload_s=elapsed, upload_mbps=size*8/1e6/max(elapsed,1e-9))
+            with returned.open('wb') as dst:
+                t = time.monotonic()
+                result = subprocess.run(remote._base() + [f"trap 'rm -f {quoted}' EXIT HUP INT TERM; cat {quoted}"],
+                                        stdout=dst, stderr=subprocess.PIPE, timeout=remaining())
+                elapsed = time.monotonic() - t
+            if result.returncode:
+                raise RuntimeError('probe download SSH failed')
+            if returned.stat().st_size != size or hashlib.sha256(native.read_bytes()).digest() != hashlib.sha256(returned.read_bytes()).digest():
+                raise RuntimeError('probe roundtrip bytes failed integrity check')
+            receipt.update(download_s=elapsed, download_mbps=size*8/1e6/max(elapsed,1e-9))
+            failures = [f'{direction} below configured minimum' for direction in ('upload','download')
+                        if (getattr(profile, f'min_measured_{direction}_mbps') is not None
+                            and receipt[f'{direction}_mbps'] < getattr(profile, f'min_measured_{direction}_mbps'))]
+            receipt['status'] = 'rejected' if failures else 'ok'
+            if failures:
+                receipt['error'] = '; '.join(failures)
+    except (OSError, subprocess.SubprocessError, RuntimeError) as error:
+        receipt['error'] = f'{type(error).__name__}: {error}'
+    finally:
+        # Best effort within the SAME total deadline; rental teardown is separate.
+        budget = deadline - time.monotonic()
+        if budget > 0:
+            try:
+                result = remote.run(f'rm -f {quoted}', check=False, timeout=budget)
+                receipt['remote_cleanup_confirmed'] = result.returncode == 0
+            except (OSError, subprocess.SubprocessError, RuntimeError):
+                receipt['remote_cleanup_confirmed'] = False
+        else:
+            receipt['remote_cleanup_confirmed'] = False
+        receipt['wall_s'] = time.monotonic() - start
+    return receipt

gipper/placement.py

@@ -0,0 +1,211 @@
+"""What a job tells gipper about itself so offers can be judged on the whole run,
+not the hourly price: `[placement]` in the job file. Everything is optional;
+whatever is missing comes from memory (gipper.history) or a stated default.
+
+    [placement]
+    objective = "auto"            # auto | cost | time (see docs/placement.md)
+    compute_s = 550               # expected compute seconds once inputs are up
+    compute_s_by_gpu = { A40 = 250 }   # per GPU, where known
+    setup_s = 120                 # the job's own setup, excluding the downloads below
+    setup_download_gb = 8.5       # what the job fetches itself (weights, wheels)
+    upload_gb = 0.1               # default: the size of [[inputs]]
+    download_gb = 0.2             # outputs coming back
+    transfer_efficiency = 0.5     # share of a host's advertised speed to expect
+    min_host_download_mbps = 500  # hard filters on what the provider advertises
+    min_host_upload_mbps = 100
+    min_cuda = 12.8
+    min_compute_capability = 8.0
+    probe_transfer_mb = 2         # measure the ssh path before uploading (MiB each way)
+    probe_timeout_s = 120
+    min_measured_upload_mbps = 1
+    min_measured_download_mbps = 1
+    min_dlperf = 30               # Vast's generic DLPerf score: a filter, never a speed
+    client_upload_mbps = 40       # this end's link, if it's the bottleneck
+    client_download_mbps = 300
+    fallback_mbps = 100           # a link nobody has advertised or measured
+
+Real-time work (`profile = "interactive"`, objective "latency") ranks by measured
+round trip to where the user is, then preferred country, then distance, then the
+usual score:
+
+    profile = "interactive"
+    latency_target = "interactive-client"            # names the client the RTTs were measured from;
+                                                      # "here" means this machine, so its pings count
+    measured_rtt_ms_by_machine = { "vast:machine:12345" = 28 }
+    max_rtt_ms = 50                                   # needs a measurement: unmeasured offers fail it
+    probe_rtt = true                                  # ping candidates before renting (default for interactive)
+    preferred_countries = ["CA", "US"]
+    near_latitude = 43.65                             # with max_distance_km: offers without
+    near_longitude = -79.38                           # coordinates fail it
+    max_distance_km = 1500
+"""
+import fnmatch
+import math
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+
+OBJECTIVES = ("auto", "cost", "time", "latency")
+
+
+@dataclass
+class Placement:
+    objective: str = "auto"
+    profile: str = "batch"               # batch | interactive
+    compute_s: float | None = None
+    compute_s_by_gpu: dict = field(default_factory=dict)
+    setup_s: float | None = None
+    setup_download_gb: float = 0.0
+    upload_gb: float | None = None
+    download_gb: float = 0.0
+    transfer_efficiency: float = 0.5
+    min_host_download_mbps: float | None = None
+    min_host_upload_mbps: float | None = None
+    min_cuda: float | None = None
+    min_compute_capability: float | None = None
+    probe_transfer_mb: float = 0.0
+    probe_timeout_s: float = 120.0
+    min_measured_upload_mbps: float | None = None
+    min_measured_download_mbps: float | None = None
+    min_dlperf: float | None = None
+    client_upload_mbps: float | None = None
+    client_download_mbps: float | None = None
+    fallback_mbps: float = 100.0
+    preferred_countries: list = field(default_factory=list)
+    near_latitude: float | None = None
+    near_longitude: float | None = None
+    max_distance_km: float | None = None
+    max_rtt_ms: float | None = None
+    latency_target: str = ""
+    measured_rtt_ms_by_machine: dict = field(default_factory=dict)
+    probe_rtt: bool | None = None        # default: on for interactive jobs
+
+
+def _number(v):
+    return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)
+
+
+def load_placement(data, *, error=ValueError):
+    """The job's [placement] table (absent: all defaults), validated."""
+    data = dict(data or {})
+    unknown = set(data) - {f.name for f in fields(Placement)}
+    if unknown:
+        raise error(f"[placement] has unknown fields: {', '.join(sorted(unknown))} (see gipper/placement.py)")
+    if data.get("profile") == "interactive":
+        data.setdefault("objective", "latency")
+        data.setdefault("probe_rtt", True)
+    p = Placement(**data)
+    if p.objective not in OBJECTIVES or p.profile not in ("batch", "interactive"):
+        raise error(f"placement.profile is batch or interactive; objective one of {', '.join(OBJECTIVES)}")
+    if (p.objective == "latency") != (p.profile == "interactive"):
+        raise error('placement: objective "latency" goes with profile "interactive", and only with it')
+    for name in ("compute_s", "setup_s", "setup_download_gb", "upload_gb", "download_gb", "min_host_download_mbps",
+                 "min_host_upload_mbps", "min_cuda", "min_compute_capability", "probe_transfer_mb", "probe_timeout_s",
+                 "min_measured_upload_mbps", "min_measured_download_mbps", "min_dlperf", "client_upload_mbps",
+                 "client_download_mbps", "fallback_mbps", "max_distance_km", "max_rtt_ms"):
+        v = getattr(p, name)
+        if v is not None and (not _number(v) or v < 0):
+            raise error(f"placement.{name} must be a non-negative number")
+    if not (_number(p.transfer_efficiency) and 0 < p.transfer_efficiency <= 1):
+        raise error("placement.transfer_efficiency must be in (0, 1]")
+    if not isinstance(p.compute_s_by_gpu, dict) or not all(isinstance(k, str) and _number(v) and v > 0
+                                                           for k, v in p.compute_s_by_gpu.items()):
+        raise error("placement.compute_s_by_gpu maps GPU names to seconds")
+    if p.probe_transfer_mb and not 1 <= p.probe_transfer_mb <= 64 or p.probe_timeout_s > 300:
+        raise error("placement.probe_transfer_mb is 0 (off) or 1-64 MiB; probe_timeout_s at most 300")
+    if (p.min_measured_upload_mbps or p.min_measured_download_mbps) and not p.probe_transfer_mb:
+        raise error("placement.min_measured_*_mbps need probe_transfer_mb")
+    if not p.fallback_mbps:
+        raise error("placement.fallback_mbps must be positive")
+    if not isinstance(p.measured_rtt_ms_by_machine, dict) or not all(
+            isinstance(k, str) and _number(v) and v > 0 for k, v in p.measured_rtt_ms_by_machine.items()):
+        raise error('placement.measured_rtt_ms_by_machine maps "provider:machine:id" to milliseconds')
+    if not isinstance(p.preferred_countries, list) or not all(isinstance(c, str) and len(c) == 2
+                                                               for c in p.preferred_countries):
+        raise error("placement.preferred_countries is a list of ISO country codes")
+    p.preferred_countries = [c.upper() for c in p.preferred_countries]
+    coords = (p.near_latitude, p.near_longitude)
+    if any(v is not None for v in coords) and not (all(_number(v) for v in coords)
+                                                   and abs(coords[0]) <= 90 and abs(coords[1]) <= 180):
+        raise error("placement needs a valid near_latitude and near_longitude pair")
+    if p.max_distance_km is not None and p.near_latitude is None:
+        raise error("placement.max_distance_km needs near_latitude and near_longitude")
+    if (p.max_rtt_ms is not None or p.measured_rtt_ms_by_machine) and not p.latency_target:
+        raise error("placement: RTT measurements need latency_target, naming where they were measured from")
+    return p
+
+
+def distance_km(offer, p):
+    """Great-circle distance from the job's near_* point to the offer, if both are known."""
+    lat, lon = offer.metrics.get("latitude"), offer.metrics.get("longitude")
+    if p.near_latitude is None or not (_number(lat) and _number(lon)):
+        return None
+    a, b, c, d = map(math.radians, (p.near_latitude, p.near_longitude, lat, lon))
+    h = math.sin((c - a) / 2) ** 2 + math.cos(a) * math.cos(c) * math.sin((d - b) / 2) ** 2
+    return 6371.0088 * 2 * math.asin(min(1, math.sqrt(h)))
+
+
+def target_is_here(p):
+    from gipper.latency import HERE
+    return p.latency_target in ("here", HERE)
+
+
+def rtt_ms(offer, p):
+    """A round trip that counts as measured from the job's latency_target: the job's
+    own measurement, or a ping from here when the target is here."""
+    machine = offer.ref.get("machine")
+    own = p.measured_rtt_ms_by_machine.get(f"{offer.provider}:machine:{machine}") if machine is not None else None
+    if own is not None:
+        return own
+    return offer.metrics.get("rtt_ms_here") if target_is_here(p) else None
+
+
+def best_rtt(offer, p, history=None):
+    """(ms, basis): the best round-trip figure there is for ranking. Measured from the
+    target first, then pinged from here just now, then memory of this machine, then
+    the median for its country, all from here."""
+    from gipper.latency import HERE
+    own = rtt_ms(offer, p)
+    if own is not None:
+        return own, "measured" if not target_is_here(p) or offer.metrics.get("rtt_ms_here") != own else "pinged from here"
+    if offer.metrics.get("rtt_ms_here") is not None:
+        return offer.metrics["rtt_ms_here"], "pinged from here (proxy)"
+    if history is not None:
+        v = history.rtt(offer.provider, offer.ref.get("machine"), HERE)
+        if v is not None:
+            return v, "memory of this machine"
+        v = history.country_rtt(offer.country, HERE)
+        if v is not None:
+            return v, f"memory of {offer.country}"
+    return None, "unknown"
+
+
+def estimate_offer(job, offer, *, upload_gb=None):
+    """0.1's name for the whole-run estimate (gipper.costs.estimate)."""
+    from gipper.costs import estimate
+    from gipper.history import History
+    if upload_gb is not None:
+        job.placement.upload_gb = upload_gb
+    return estimate(job, offer, History.load())
+
+
+def rank_for_job(offers, job, *, tie_key=None):
+    """0.1's name for filtering and ranking offers for a job."""
+    from gipper.market import admit, rank
+    offers = admit(offers, min_mem_gb=job.min_mem_gb, regions=job.regions, ports=job.ports, placement=job.placement)
+    return rank(offers, job.prefer, job=job)
+
+
+def input_gb(job):
+    """Bytes the [[inputs]] will upload (decimal GB), honouring their excludes."""
+    size = 0
+    for t in job.inputs:
+        root = Path(t.src)
+        for path in (root.rglob("*") if root.is_dir() else [root]):
+            if path.is_symlink() or not path.is_file():
+                continue
+            rel = path.relative_to(root) if root.is_dir() else Path(path.name)
+            if any(fnmatch.fnmatch(str(rel), pat) or any(fnmatch.fnmatch(part, pat) for part in rel.parts)
+                   for pat in t.exclude):
+                continue
+            size += path.stat().st_size
+    return size / 1e9

gipper/providers/__init__.py

@@ -0,0 +1,50 @@
+"""GPU markets gipper can rent from. Each provider answers the same questions:
+
+    offers(job)                      -> [Offer] that fit (memory, regions, ports)
+    create(offer, job, pubkey, name) -> {"id", "usd_h", "gpu"}; raises Unavailable if
+                                        the offer is gone, so the next one is tried
+    wait_ready(id, job)              -> (Remote, {"machine", "gpu", "ports"}); raises
+                                        BadHost if the machine will never come up
+    terminate(id)
+    list_ours()                      -> [{"id", "name", "started"}] for names gipper-*
+    account()                        -> one line on balance and spend
+    billed(since)                    -> {id: (usd, detail)} actually charged, or None if
+                                        the provider can't say
+
+Everything else (caps, upload, the detached run, checkpoints, teardown, receipts)
+is the same for every provider and lives in gipper.run.
+"""
+from importlib import import_module
+
+from gipper.config import secret
+
+NAMES = ("runpod", "vast", "shadeform")
+
+
+class Unavailable(RuntimeError):
+    """The offer was taken or the market has nothing free: try the next offer."""
+
+
+class BadHost(RuntimeError):
+    """The machine is busy, broken or never came up: end it and rent another."""
+
+
+class Provider:
+    name = ""
+    key_name = ""
+    udp = False
+
+    def has_key(self):
+        return bool(secret(self.key_name, required=False))
+
+    def key(self):
+        return secret(self.key_name)
+
+    def billed(self, since):
+        return None
+
+
+def load(name):
+    if name not in NAMES:
+        raise KeyError(f"{name}: not a provider gipper knows ({', '.join(NAMES)})")
+    return import_module(f"gipper.providers.{name}").PROVIDER