verifiers 0.3.2.dev128__tar.gz → 0.3.2.dev130__tar.gz

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev128
+Version: 0.3.2.dev130
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/cli/debug.py

@@ -3,10 +3,12 @@
 import asyncio
 import contextlib
 import logging
+import os
 import shlex
 import sys
 import time
 import traceback
+import uuid
 from collections.abc import Awaitable
 from pathlib import Path
 from typing import Any
@@ -316,6 +318,8 @@ async def run_debug(config: DebugConfig) -> list[Trace]:
 
 
 def main(argv: list[str] | None = None) -> None:
+    # The run identity: every process this run spawns inherits it.
+    os.environ.setdefault("VF_RUN_ID", uuid.uuid4().hex)
     argv = with_positional_taskset(
         list(sys.argv[1:]) if argv is None else list(argv), flag="--taskset.id"
     )

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/cli/eval/runner.py

@@ -9,6 +9,7 @@ runs env servers); this CLI is the quick local path.
 import asyncio
 import contextlib
 import logging
+import os
 import time
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from typing import TypeVar, cast
@@ -139,6 +140,8 @@ async def run_eval(config: EvalConfig) -> list[Episode]:
 
     # Opened before the first rollout so every episode streams as it lands.
     run = open_run(config, push_state, num_examples=len(tasks))
+    # The run identity: every process this run spawns inherits it.
+    os.environ.setdefault("VF_RUN_ID", config.run.id)
     # Resumed rollouts are part of this run too.
     log_episodes(run, finished)
 

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/cli/gepa.py

@@ -9,7 +9,9 @@ and the actual parse is `pydantic_config.cli`.
 """
 
 import logging
+import os
 import sys
+import uuid
 
 from pydantic_config import cli
 
@@ -32,6 +34,8 @@ USAGE = "usage: uv run vf-gepa [<taskset-id>] [--env.id <id>] --model <model> [o
 
 
 def main(argv: list[str] | None = None) -> None:
+    # The run identity: every process this run spawns inherits it.
+    os.environ.setdefault("VF_RUN_ID", uuid.uuid4().hex)
     argv = with_positional_taskset(list(sys.argv[1:]) if argv is None else list(argv))
 
     if not argv or any(arg in ("-h", "--help") for arg in argv):

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/cli/replay.py

@@ -12,8 +12,10 @@ import asyncio
 import contextlib
 import json
 import logging
+import os
 import sys
 import time
+import uuid
 from pathlib import Path
 
 from pydantic_config import cli
@@ -197,6 +199,8 @@ async def run_replay(config: ReplayConfig, source: Path, out: Path) -> list[Trac
 
 
 def main(argv: list[str] | None = None) -> None:
+    # The run identity: every process this run spawns inherits it.
+    os.environ.setdefault("VF_RUN_ID", uuid.uuid4().hex)
     argv = list(sys.argv[1:]) if argv is None else list(argv)
     if not argv or any(a in ("-h", "--help") for a in argv):
         print(USAGE)

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/cli/validate.py

@@ -4,9 +4,11 @@ import asyncio
 import contextlib
 import json
 import logging
+import os
 import shutil
 import sys
 import time
+import uuid
 from collections import Counter, defaultdict
 from collections.abc import Mapping, Sequence
 from pathlib import Path
@@ -425,6 +427,8 @@ async def run_validate(config: ValidateConfig) -> list[dict]:
 
 
 def main(argv: list[str] | None = None) -> None:
+    # The run identity: every process this run spawns inherits it.
+    os.environ.setdefault("VF_RUN_ID", uuid.uuid4().hex)
     argv = with_positional_taskset(
         list(sys.argv[1:]) if argv is None else list(argv), flag="--taskset.id"
     )

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/interception/tunnel/prime.py

@@ -9,15 +9,19 @@ from collections.abc import AsyncIterator
 from typing import Literal
 
 from verifiers.v1.interception.tunnel.base import BaseTunnelConfig, Tunnel
-from verifiers.v1.runtimes.limiters import creation_limiter
+from verifiers.v1.runtimes.limiters import CreationLimiter
 from verifiers.v1.utils.aio import run_shielded
 from verifiers.v1.utils.prime import ensure_prime_auth
+from verifiers.v1.utils.scope import run_scope
 
 # The prime_tunnel service caps tunnel starts at 512/min per API token — a property of the
-# tunnel service, shared by every process for the user that opens one. One user-global
+# tunnel service, shared by every process of a run that opens one. One run-scoped
 # limiter, not a per-runtime config knob.
 _TUNNELS_PER_MIN = 512
-TUNNEL_LIMITER = creation_limiter(_TUNNELS_PER_MIN / 60, "prime-tunnel")
+
+
+def tunnel_limiter() -> CreationLimiter:
+    return CreationLimiter("prime-tunnel", run_scope(), _TUNNELS_PER_MIN / 60)
 
 
 class PrimeTunnelConfig(BaseTunnelConfig):
@@ -35,8 +39,8 @@ class PrimeTunnel(Tunnel[PrimeTunnelConfig]):
     @contextlib.asynccontextmanager
     async def expose(self, port: int) -> AsyncIterator[str]:
         """Bridge the host `port` to a public URL via prime_tunnel (frpc). Tunnel creation
-        is network-bound and globally rate-capped (512/min, user-wide via the shared
-        `TUNNEL_LIMITER`), so transient failures are retried; a terminal one raises
+        is network-bound and rate-capped (512/min, run-wide via the shared
+        `tunnel_limiter`), so transient failures are retried; a terminal one raises
         `TunnelError`. The tunnel is torn down on exit."""
         from prime_tunnel import Tunnel as TunnelClient
 
@@ -48,7 +52,7 @@ class PrimeTunnel(Tunnel[PrimeTunnelConfig]):
             async for attempt in retrying(retries=3, label=label):
                 with attempt:
                     client = TunnelClient(local_port=port)
-                    async with TUNNEL_LIMITER:
+                    async with tunnel_limiter():
                         url = str(await client.start()).rstrip("/")
         except Exception as e:
             raise TunnelError(f"{label} failed: {e}") from e

verifiers-0.3.2.dev130/verifiers/v1/runtimes/limiters.py

@@ -0,0 +1,71 @@
+"""Creation-rate limiters for the remote runtimes.
+
+A leaky bucket backed by a lock file under the user cache (``~/.cache/verifiers``, falling
+back to the temp dir when no home is resolvable), so a provider's creation rate (Modal
+sandboxes, Prime sandboxes and tunnels) is enforced across EVERY process that shares the
+bucket — the eval process and all the elastically-spawned env-server worker processes alike —
+not just within one process. A bucket is named by the limiter's name and a scope the caller
+picks; the runtimes pass the run id, so one run's backlog (or the reservations a killed run
+left behind) never delays another run.
+"""
+
+import asyncio
+import fcntl
+import os
+import time
+from typing import Self
+
+from verifiers.v1.utils.paths import CACHE_DIR
+
+LIMITER_DIR = CACHE_DIR / "limiter"
+
+
+class CreationLimiter:
+    """An async leaky bucket shared across processes via a lock file: each `async with`
+    reserves the next `1/per_sec`-spaced slot (advancing the on-disk cursor under an exclusive
+    flock) and sleeps until it, so the aggregate creation rate across every process sharing
+    the bucket stays at `per_sec`. The reservation runs off the event loop; the wait does not
+    hold the lock. Reservations are never released, so a cancelled waiter still holds its
+    slot; the backlog drains at `per_sec` regardless."""
+
+    def __init__(self, name: str, scope: str, per_sec: float) -> None:
+        self._interval = 1 / per_sec
+        self._path = LIMITER_DIR / f"{name}-{scope.replace('/', '--')}.bucket"
+
+    def _reserve(self) -> float:
+        os.makedirs(LIMITER_DIR, exist_ok=True)
+        # Shared buckets require a clock comparable across the run's hosts.
+        with open(self._path, "a+") as f:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+            try:
+                f.seek(0)
+                data = f.read().strip()
+                now = time.time()
+                slot = max(now, float(data) if data else 0.0)
+                f.seek(0)
+                f.truncate()
+                f.write(repr(slot + self._interval))
+                f.flush()
+            finally:
+                fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+        return slot - now
+
+    async def __aenter__(self) -> Self:
+        wait = await asyncio.to_thread(self._reserve)
+        if wait > 0:
+            await asyncio.sleep(wait)
+        return self
+
+    async def __aexit__(self, *exc) -> bool:
+        return False
+
+
+def creation_limiter(
+    per_sec: float | None, name: str, scope: str
+) -> CreationLimiter | None:
+    """A limiter pacing `name`'s creation to `per_sec`/s within `scope` (None/<= 0
+    disables). All callers (and processes) sharing a name and scope share one bucket, so
+    use one rate per name."""
+    if not per_sec or per_sec <= 0:
+        return None
+    return CreationLimiter(name, scope, per_sec)

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/runtimes/modal.py

@@ -31,6 +31,7 @@ from verifiers.v1.runtimes.base import (
 )
 from verifiers.v1.runtimes.limiters import creation_limiter
 from verifiers.v1.utils.aio import run_shielded
+from verifiers.v1.utils.scope import run_scope
 
 logger = logging.getLogger(__name__)
 
@@ -93,7 +94,7 @@ class ModalConfig(NetworkPolicyConfig):
     """Disk in GB. Modal sandboxes have no disk knob, so this is accepted (so a task can
     declare it without a warning) but not enforced."""
     creates_per_sec: float | None = 40.0
-    """Pace sandbox creation to this many per second, enforced user-wide across every
+    """Pace sandbox creation to this many per second, enforced run-wide across every
     env-server worker process (None/<= 0 disables it)."""
 
     @model_validator(mode="after")
@@ -181,7 +182,9 @@ class ModalRuntime(Runtime):
         try:
             app = await modal.App.lookup.aio(_APP_NAME, create_if_missing=True)
             async with (
-                creation_limiter(self.config.creates_per_sec, "modal-sandbox")
+                creation_limiter(
+                    self.config.creates_per_sec, "modal-sandbox", run_scope()
+                )
                 or contextlib.nullcontext()
             ):
                 await run_shielded(self._create_sandbox(app))

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/runtimes/prime.py

@@ -28,6 +28,7 @@ from verifiers.v1.runtimes.base import (
 from verifiers.v1.runtimes.limiters import creation_limiter
 from verifiers.v1.utils.aio import run_shielded
 from verifiers.v1.utils.prime import ensure_prime_auth
+from verifiers.v1.utils.scope import run_scope
 
 logger = logging.getLogger(__name__)
 
@@ -87,9 +88,9 @@ class PrimeConfig(NetworkPolicyConfig):
     idle_timeout: float | None = 3600
     """Seconds of inactivity before the sandbox self-deletes (None disables)."""
     creates_per_min: int | None = None
-    """Pace sandbox creation to this many per minute, enforced user-wide across every
+    """Pace sandbox creation to this many per minute, enforced run-wide across every
     env-server worker process (None/<= 0 disables it). (Tunnel creation is limited separately
-    and globally — see interception.tunnel.prime.TUNNEL_LIMITER.)"""
+    — see interception.tunnel.prime.tunnel_limiter.)"""
 
     @model_validator(mode="after")
     def _validate_egress(self) -> "PrimeConfig":
@@ -175,7 +176,9 @@ class PrimeRuntime(Runtime):
         try:
             async with (
                 creation_limiter(
-                    (self.config.creates_per_min or 0) / 60, "prime-sandbox"
+                    (self.config.creates_per_min or 0) / 60,
+                    "prime-sandbox",
+                    run_scope(),
                 )
                 or contextlib.nullcontext()
             ):

{verifiers-0.3.2.dev128 → verifiers-0.3.2.dev130}/verifiers/v1/tasksets/harbor/taskset.py

@@ -121,9 +121,6 @@ class VerifierConfig(BaseModel):
     `None` on `HarborData` means shared — grade where the agent worked, which is still
     Harbor's default and every task that says nothing."""
 
-    image: str | None = None
-    """Pullable ref from `[verifier.environment].docker_image`. None keeps the task's
-    own image, which is what Harbor's fresh copy of `[environment]` resolves to."""
     resources: TaskResources = TaskResources()
     workdir: str | None = None
     env: dict[str, str] = Field(default_factory=dict)
@@ -159,6 +156,9 @@ class HarborData(TaskData):
     healthcheck: dict | None = None
     mcp_servers: list[dict] = Field(default_factory=list)
     """Task-declared MCP servers, preserved for served-task reconstruction."""
+    verifier_image: str | None = None
+    """Pullable image for a separate verifier, containing the complete `/tests` suite.
+    None keeps the solver image and stages the task package's tests."""
     verifier_env: dict[str, str] = Field(default_factory=dict)
     """Raw [verifier.env] entries (literals or `${VAR}`/`${VAR:-default}` templates).
     Resolved against the host environment at scoring time, like `harbor run` — so a
@@ -297,7 +297,7 @@ class HarborTask(Task[HarborData, State, HarborTaskConfig]):
         # Harbor's dedicated verifier image owns the complete test suite and its
         # dependencies. Mixing it with packaged tests can retain obsolete helpers.
         stage = "test -f /tests/test.sh"
-        if self.data.verifier is None or self.data.verifier.image is None:
+        if self.data.verifier is None or self.data.verifier_image is None:
             await runtime.write(
                 "/tmp/tests.tgz", make_tar(Path(self.data.task_dir) / "tests")
             )
@@ -391,10 +391,14 @@ def verifier_box_data(data: HarborData) -> HarborData:
     return data.model_copy(
         update={
             "name": f"{data.name} (verifier)",
-            "image": verifier.image if verifier.image is not None else data.image,
+            "image": data.verifier_image
+            if data.verifier_image is not None
+            else data.image,
             "workdir": data.workdir if fresh else verifier.workdir,
             "resources": data.resources if fresh else verifier.resources,
-            "upload_environment": data.upload_environment if fresh else False,
+            "upload_environment": data.upload_environment
+            if fresh and data.verifier_image is None
+            else False,
             "env": dict(verifier.env),
             "healthcheck": verifier.healthcheck,
             "skills": [],
@@ -524,27 +528,41 @@ def resolve_image(
     image: str | None,
     require_image: bool,
     ignore_dockerfile: bool = False,
+    *,
+    verifier: bool = False,
 ) -> str | None:
     """Choose a pullable image without silently ignoring a declared Dockerfile.
 
-    ``None`` tells the runtime to keep the harness image. That is the intended
-    fallback for tasks with no environment, but would score a Dockerfile task in
-    the wrong environment unless the user explicitly opts in.
+    ``None`` keeps the harness image for the solver, or the solver image for a
+    separate verifier. A declared verifier environment without an image implies
+    a build from tests/Dockerfile, even if that file is absent.
     """
     if image:
         return image
-    if (task_dir / "environment" / "Dockerfile").exists():
+    section = "verifier.environment" if verifier else "environment"
+    dockerfile = "tests/Dockerfile" if verifier else "environment/Dockerfile"
+    if verifier or (task_dir / dockerfile).exists():
         if ignore_dockerfile:
+            if verifier:
+                logger.warning(
+                    "%s: [%s] names no docker_image — grading in the agent's "
+                    "image rather than building %s, so the verifier runs somewhere "
+                    "the task never declared",
+                    task_dir.name,
+                    section,
+                    dockerfile,
+                )
             return None
         raise ValueError(
-            f"{task_dir.name}: environment is a Dockerfile, not a pullable "
-            "[environment].docker_image — building Dockerfiles isn't supported, so this "
+            f"{task_dir.name}: [{section}] needs a pullable docker_image instead of "
+            f"building {dockerfile} — building Dockerfiles isn't supported, so this "
             "task can't run (it would otherwise score against the wrong default image). "
-            "Pass --env.taskset.ignore-dockerfile to run it on the harness runtime's image instead."
+            "Pass --env.taskset.ignore-dockerfile to load it with a fallback image, "
+            "then override the task's image or verifier_image with a pre-built image."
         )
     if require_image:
         raise ValueError(
-            f"{task_dir.name}: no [environment].docker_image and require_image=True"
+            f"{task_dir.name}: no [{section}].docker_image and require_image=True"
         )
     return None
 
@@ -559,10 +577,27 @@ def parse_task(task_dir: Path, idx: int, harbor_config: HarborConfig) -> HarborD
     parsed = harbor_task.config
     artifacts, hooks, verifier = parse_verifier_extras(task_dir, parsed, harbor_config)
     environment = parsed.environment
+    image = resolve_image(
+        task_dir,
+        environment.docker_image,
+        harbor_config.require_image,
+        harbor_config.ignore_dockerfile,
+    )
+    verifier_image = (
+        resolve_image(
+            task_dir,
+            parsed.verifier.environment.docker_image,
+            require_image=True,
+            ignore_dockerfile=harbor_config.ignore_dockerfile,
+            verifier=True,
+        )
+        if verifier is not None and parsed.verifier.environment is not None
+        else None
+    )
     environment_dir = task_dir / "environment"
     upload_environment = should_upload_environment_dir(
         environment_dir,
-        docker_image=environment.docker_image,
+        docker_image=image,
     )
     network = parsed.agent.explicit_phase_policy() or environment.resolve_baseline()
     task, meta = parsed.task, parsed.metadata
@@ -590,12 +625,7 @@ def parse_task(task_dir: Path, idx: int, harbor_config: HarborConfig) -> HarborD
         name=harbor_task.name,
         description=task.description if task else None,
         prompt=harbor_task.instruction.strip(),
-        image=resolve_image(
-            task_dir,
-            environment.docker_image,
-            harbor_config.require_image,
-            harbor_config.ignore_dockerfile,
-        ),
+        image=image,
         workdir=environment.workdir,
         network_allow=(
             ["*"]
@@ -622,6 +652,7 @@ def parse_task(task_dir: Path, idx: int, harbor_config: HarborConfig) -> HarborD
         **environment.model_dump(
             include={"env", "healthcheck", "mcp_servers"}, mode="json"
         ),
+        verifier_image=verifier_image,
         verifier_env=parsed.verifier.env,
         artifacts=artifacts,
         collect=hooks,
@@ -719,23 +750,6 @@ def parse_verifier_environment(
     if environment is None:  # unreachable while the mode is SEPARATE
         raise ValueError(f"{task_dir.name}: separate verifier resolved no environment")
     declared = parsed.verifier.environment is not None
-
-    if declared and environment.docker_image is None:
-        if not harbor_config.ignore_dockerfile:
-            raise ValueError(
-                f"{task_dir.name}: [verifier.environment] names no docker_image, so "
-                "Harbor would build the verifier image from tests/Dockerfile. Verifiers "
-                "pulls images and never builds them: build and push it yourself (e.g. "
-                "`prime images push`) and set [verifier.environment].docker_image to the "
-                "resulting ref, or pass --taskset.ignore-dockerfile to grade in the "
-                "agent's image instead."
-            )
-        logger.warning(
-            "%s: [verifier.environment] names no docker_image — grading in the agent's "
-            "image rather than building tests/Dockerfile, so the verifier runs somewhere "
-            "the task never declared",
-            task_dir.name,
-        )
     unsupported = [field for field in ("tpu",) if getattr(environment, field, None)]
     if environment.os != TaskOS.LINUX or unsupported:
         raise ValueError(
@@ -746,7 +760,6 @@ def parse_verifier_environment(
 
     network = parsed.verifier.explicit_phase_policy() or environment.resolve_baseline()
     return VerifierConfig(
-        image=environment.docker_image if declared else None,
         # A declared environment states its own resources; what it leaves out is the
         # run's default, not the agent task's. A fresh copy is the task's environment,
         # so it keeps whatever the agent box resolved to.

verifiers-0.3.2.dev130/verifiers/v1/utils/scope.py

@@ -0,0 +1,27 @@
+"""The scope that state shared by a run's processes is keyed by."""
+
+import logging
+import os
+import uuid
+
+logger = logging.getLogger(__name__)
+
+_process_scope: str | None = None
+
+
+def run_scope() -> str:
+    """``$VF_RUN_ID``, set by every entrypoint (the `vf-*` CLIs and the prime-rl launchers)
+    and inherited by spawned env servers and pool workers. A process started without one
+    gets a scope of its own, minted once per process."""
+    global _process_scope
+    run_id = os.environ.get("VF_RUN_ID")
+    if run_id:
+        return run_id
+    if _process_scope is None:
+        _process_scope = uuid.uuid4().hex
+        logger.warning(
+            "VF_RUN_ID is unset - run-scoped state such as creation limiters covers only "
+            "this process (scope %s)",
+            _process_scope,
+        )
+    return _process_scope

verifiers-0.3.2.dev128/verifiers/v1/runtimes/limiters.py

@@ -1,79 +0,0 @@
-"""User-global creation-rate limiters for the remote runtimes.
-
-A leaky bucket backed by a lock file under the user cache (``~/.cache/verifiers``, falling
-back to the temp dir when no home is resolvable), so a provider's per-account creation rate
-(Modal sandboxes, Prime tunnels) is enforced across EVERY process for the user —
-the single-process eval and all the elastically-spawned env-server worker processes alike — not
-just within one process. Keyed by name: one bucket file per name, shared by every process (and
-run) for the user.
-"""
-
-import asyncio
-import fcntl
-import os
-import time
-from typing import Self
-
-from verifiers.v1.utils.paths import CACHE_DIR
-
-LIMITER_DIR = CACHE_DIR / "limiter"
-
-
-class CreationLimiter:
-    """An async leaky bucket shared across processes via a lock file: each `async with`
-    reserves the next `1/per_sec`-spaced slot (advancing the on-disk cursor under an exclusive
-    flock) and sleeps until it, so the aggregate creation rate across all of the user's
-    processes stays at `per_sec`. The reservation runs off the event loop; the wait does not
-    hold the lock. Backlogs over five minutes fail rather than silently stalling creation."""
-
-    def __init__(self, name: str, per_sec: float) -> None:
-        self._interval = 1 / per_sec
-        self._path = LIMITER_DIR / f"{name}.bucket"
-
-    def _reserve(self) -> float:
-        os.makedirs(LIMITER_DIR, exist_ok=True)
-        # Shared buckets require a clock comparable across hosts and boots.
-        with open(self._path, "a+") as f:
-            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
-            try:
-                f.seek(0)
-                data = f.read().strip()
-                now = time.time()
-                slot = max(now, float(data) if data else 0.0)
-                wait = slot - now
-                if wait > 5 * 60:
-                    raise TimeoutError(
-                        f"{self._path.stem} creation limiter backlog of {wait:.1f}s "
-                        f"exceeds 300s ({self._path})"
-                    )
-                f.seek(0)
-                f.truncate()
-                f.write(repr(slot + self._interval))
-                f.flush()
-                return wait
-            finally:
-                fcntl.flock(f.fileno(), fcntl.LOCK_UN)
-
-    async def __aenter__(self) -> Self:
-        wait = await asyncio.to_thread(self._reserve)
-        if wait > 0:
-            await asyncio.sleep(wait)
-        return self
-
-    async def __aexit__(self, *exc) -> bool:
-        return False
-
-
-_creation_limiters: dict[str, CreationLimiter] = {}
-
-
-def creation_limiter(per_sec: float | None, name: str) -> CreationLimiter | None:
-    """A user-global limiter pacing `name`'s creation to `per_sec`/s (None/<= 0 disables).
-
-    All callers (and processes) sharing a `name` share one bucket, so use one rate per name."""
-    if not per_sec or per_sec <= 0:
-        return None
-    limiter = _creation_limiters.get(name)
-    if limiter is None:
-        limiter = _creation_limiters[name] = CreationLimiter(name, per_sec)
-    return limiter