verifiers 0.3.2.dev208__py3-none-any.whl → 0.3.2.dev209__py3-none-any.whl

verifiers/v1/harnesses/utils/install.py

@@ -50,7 +50,16 @@ async def ensure_installed(
         f"mkdir -p {shlex.quote(directory)} && "
         f'if l=$(command -v flock || command -v lockf); then "$l" {lock} {run}; else {spinlock}; fi'
     )
-    result = await runtime.run(["sh", "-c", guarded], env)
+    if runtime.user is None:
+        result = await runtime.run(["sh", "-c", guarded], env)
+    else:
+        # Install as root (system packages), keeping uv's Python in `directory`, then
+        # open it to the agent user: some installers leave it private.
+        python_dir = {"UV_PYTHON_INSTALL_DIR": f"{directory}/python"}
+        shareable = f"{guarded} && chmod -R a+rX {shlex.quote(directory)}"
+        result = await runtime.with_user(None).run(
+            ["sh", "-c", shareable], {**python_dir, **env}
+        )
     if result.exit_code != 0:
         detail = (result.stderr.strip() or result.stdout.strip())[-500:]
         raise RuntimeError(f"{label} install failed: {detail}")

verifiers/v1/mcp/launch.py

@@ -234,7 +234,9 @@ async def _cached_package(src: Path) -> tuple[str, bytes]:
             del _PACKAGE_BUILD_STATES[key]
 
 
-async def _install_in_sandbox(server: ServerBase, runtime: Runtime) -> str:
+async def _install_in_sandbox(server: ServerBase, agent: Runtime) -> str:
+    # Install as root; the agent user only runs the server.
+    runtime = agent if agent.user is None else agent.with_user(None)
     # Prime VMs mount /tmp as a small tmpfs, while the runtime workdir lives on
     # the VM's root disk. Keep source, build scratch space, and uv's cache on the
     # durable runtime filesystem so ordinary dependency installs cannot exhaust
@@ -244,35 +246,51 @@ async def _install_in_sandbox(server: ServerBase, runtime: Runtime) -> str:
     temp = str(PurePosixPath(workdir) / ".vf-tmp")
     cache = str(PurePosixPath(workdir) / ".vf-uv-cache")
     venv = str(PurePosixPath(workdir) / ".vf-venv")
+    python_dir = str(PurePosixPath(workdir) / ".vf-python")
     root_q, temp_q, cache_q, venv_q = map(shlex.quote, (root, temp, cache, venv))
     # Colocated servers and borrowed views install into one physical environment.
     # Serialize its mutations and only remember sources after a successful install.
     async with runtime._mcp_install_lock:
         sources = dict.fromkeys((_package_dir(ServerBase), _package_dir(type(server))))
         pending = [source for source in sources if source not in runtime._mcp_sources]
-        if not pending:
-            return f"{venv}/bin/python"
-        setup = (
-            f"set -e; mkdir -p {root_q} {temp_q} {cache_q}; "
-            f"export TMPDIR={temp_q} UV_CACHE_DIR={cache_q}; "
-            'export PATH="$HOME/.local/bin:$PATH"; '
-        )
-        if not runtime._mcp_sources:
-            # Failed installs can leave the venv behind; retain it when retrying.
-            setup += f"{_ENSURE_UV}; uv venv --allow-existing {venv_q}; "
-        # Drain remote writes and installs before cancellation releases the lock.
-        for source in pending:
-            name, data = await _cached_package(Path(source))
-            remote = f"{root}/{name}"
-            await run_shielded(runtime.write(remote, data))
-            setup += f"uv pip install --python {venv_q} {shlex.quote(remote)}; "
-        result = await run_shielded(runtime.run(["sh", "-c", setup], {}))
-        if result.exit_code != 0:
-            raise ToolsetError(
-                f"server {server.server_name!r} install failed in runtime: "
-                f"{(result.stderr or result.stdout).strip()[-2000:]}"
+        if pending:
+            setup = (
+                f"set -e; mkdir -p {root_q} {temp_q} {cache_q}; "
+                f"export TMPDIR={temp_q} UV_CACHE_DIR={cache_q}; "
+                'export PATH="$HOME/.local/bin:$PATH"; '
             )
-        runtime._mcp_sources.update(pending)
+            if agent.user is not None:
+                setup += f"export UV_PYTHON_INSTALL_DIR={shlex.quote(python_dir)}; "
+            if not runtime._mcp_sources:
+                # Failed installs can leave the venv behind; retain it when retrying.
+                setup += f"{_ENSURE_UV}; uv venv --allow-existing {venv_q}; "
+            # Drain remote writes and installs before cancellation releases the lock.
+            for source in pending:
+                name, data = await _cached_package(Path(source))
+                remote = f"{root}/{name}"
+                await run_shielded(runtime.write(remote, data))
+                setup += f"uv pip install --python {venv_q} {shlex.quote(remote)}; "
+            result = await run_shielded(runtime.run(["sh", "-c", setup], {}))
+            if result.exit_code != 0:
+                raise ToolsetError(
+                    f"server {server.server_name!r} install failed in runtime: "
+                    f"{(result.stderr or result.stdout).strip()[-2000:]}"
+                )
+            runtime._mcp_sources.update(pending)
+        if agent.user is not None:
+            # Root's uv lives in its home; copy it into the venv, open to the agent.
+            python_q = shlex.quote(python_dir)
+            share = (
+                'set -e; export PATH="$HOME/.local/bin:$PATH"; '
+                f'cp "$(command -v uv)" {venv_q}/bin/uv; chmod -R a+rX {venv_q}; '
+                f"[ ! -d {python_q} ] || chmod -R a+rX {python_q}"
+            )
+            result = await run_shielded(runtime.run(["sh", "-c", share], {}))
+            if result.exit_code != 0:
+                raise ToolsetError(
+                    f"server {server.server_name!r} could not be shared with "
+                    f"{agent.user!r}: {(result.stderr or result.stdout).strip()[-2000:]}"
+                )
     return f"{venv}/bin/python"
 
 
@@ -338,12 +356,18 @@ async def serve_in_runtime(
     command = [python, "-m", type(server).__module__]
     if runtime.type != "subprocess":
         # Providers may invoke uv after the install shell exits, so preserve its PATH.
+        path = "$HOME/.local/bin:$PATH"
+        if runtime.user is not None:
+            path = f"{PurePosixPath(python).parent}:{path}"
         command = [
             "sh",
             "-c",
-            f'export PATH="$HOME/.local/bin:$PATH"; exec {shlex.join(command)}',
+            f'export PATH="{path}"; exec {shlex.join(command)}',
         ]
     log = f"vf_tool_{server.server_name}.log"
+    if runtime.user is not None:
+        # The agent user may not be able to write the workdir.
+        log = f"/tmp/vf_tool_{server.server_name}-{uuid.uuid4().hex[:8]}.log"
     await runtime.run_background(command, env, log)
     if fixed is not None:
         port = fixed

verifiers/v1/rollout.py

@@ -59,7 +59,7 @@ _HOME_PROBE = (
 )
 
 
-async def agent_runtime(runtime: Runtime, user: str | None) -> Runtime:
+async def resolve_agent_runtime(runtime: Runtime, user: str | None) -> Runtime:
     """The runtime the harness runs on: `runtime` itself, or a view running as `user`
     with `HOME` set to its home. `user` must exist with a home directory it can write
     (task authors ship it in the image), and the view must really run as it, so a
@@ -72,8 +72,7 @@ async def agent_runtime(runtime: Runtime, user: str | None) -> Runtime:
         raise TaskError(f"agent_user {user!r} does not exist in the image")
     if lookup.exit_code != 0:
         raise TaskError(f"agent_user {user!r} has no home directory ({home})")
-    view = runtime.with_user(user)
-    view = view.with_env({**view.env, "HOME": home})
+    view = runtime.with_user(user, home=home)
     probe = await view.run(["sh", "-c", 'id -un; test -w "$HOME" && echo writable'], {})
     effective, *rest = probe.stdout.split() or [""]
     if effective != user:
@@ -168,6 +167,7 @@ class Rollout:
         self._endpoint: str | None = None
         self._urls: dict[str, str] = {}
         self._harness_session: HarnessSession | None = None
+        self._agent_runtime: Runtime | None = None
         self.deadline_at: float | None = None
         """The active harness segment's absolute deadline (event-loop clock), or
         None between segments / when unbounded. An interaction spends one cumulative
@@ -279,7 +279,13 @@ class Rollout:
                 asyncio.timeout_at(setup_deadline) as setup_timeout,
                 boundary(HarnessError, "harness setup"),
             ):
-                await self.harness.setup(runtime)
+                # The harness, its colocated tools, and its session run as the task's
+                # `agent_user` (just `runtime` when unset). Task setup and scoring,
+                # interception, and the execution policy keep the default `runtime`.
+                self._agent_runtime = await resolve_agent_runtime(
+                    runtime, self.task.data.agent_user
+                )
+                await self.harness.setup(self._agent_runtime)
             async with boundary(ToolsetError, "building tool servers"):
                 toolsets = self.task.toolsets(self.task.config)
             # `base_url` is the interception server's reachable URL for this rollout.
@@ -304,7 +310,7 @@ class Rollout:
             self._urls = await self._stack.enter_async_context(
                 serve_tools(
                     toolsets,
-                    runtime,
+                    self._agent_runtime,
                     shared=self._shared_tools,
                     state_secret=state_secret,
                     state_route=self.trace.id,
@@ -415,7 +421,7 @@ class Rollout:
                     self._harness_session = await self.harness.session(
                         self.ctx,
                         self.trace,
-                        await agent_runtime(runtime, harness_data.agent_user),
+                        self._agent_runtime,
                         self._endpoint,
                         self._secret,
                         self._urls,
@@ -606,7 +612,7 @@ class Rollout:
                         # Cross-trace judgement runs later, after the runtime is gone.
                         await asyncio.gather(
                             self.task.score(trace, runtime),
-                            self.harness.score(trace, runtime),
+                            self.harness.score(trace, self._agent_runtime or runtime),
                         )
                 except TimeoutError:
                     self.timeout("scoring")

verifiers/v1/runtimes/base.py

@@ -139,7 +139,7 @@ class BaseRuntimeInfo(BaseConfig):
 
 
 class Runtime(ABC):
-    __slots__ = ("env", "user")
+    __slots__ = ("env", "home", "user")
 
     is_local: bool = True
     """Whether this runtime exchanges host-local URLs without a public tunnel. True for
@@ -167,11 +167,14 @@ class Runtime(ABC):
         self.env: dict[str, str] = {}
         self.user: str | None = None
         """Existing user this view runs commands as; None uses the runtime's default."""
+        self.home: str | None = None
+        """`HOME` for `user`'s processes; None leaves the runtime's own."""
         self._uv_interpreters: dict[str, str] = {}
         self._uv_script_locks: dict[str, asyncio.Lock] = {}
         self._mcp_sources: set[str] = set()
         self._mcp_install_lock = asyncio.Lock()
         self._setup_claimed = False
+        self._curl_ready = False
         self.stopped = False
         """Whether teardown has begun (set by `stop`). A stopped runtime is dead: a rollout
         refuses to borrow one — the owner tore it down, so any use is a lifetime bug in the
@@ -213,7 +216,8 @@ class Runtime(ABC):
 
     def process_env(self, env: dict[str, str]) -> dict[str, str]:
         """Combine the task's runtime-wide environment with one process's values."""
-        return {**self.env, **env}
+        home = {} if self.home is None else {"HOME": self.home}
+        return {**self.env, **home, **env}
 
     def with_env(self, env: dict[str, str]) -> "Runtime":
         """Share this physical runtime through a view with its own process environment."""
@@ -223,10 +227,9 @@ class Runtime(ABC):
         runtime.env = dict(env)
         return runtime
 
-    def with_user(self, user: str | None) -> "Runtime":
-        """Share this physical runtime through a view that runs commands as `user`, an
-        existing user in the box (None keeps the default). Only the view runs as `user`:
-        setup, collection, and grading keep using the original runtime."""
+    def with_user(self, user: str | None, home: str | None = None) -> "Runtime":
+        """A view of this runtime whose commands and file I/O run as `user` (an existing
+        user in the box) with `HOME` set to `home`; None returns the default user."""
         if user is not None and not self.supports_user:
             raise ValueError(
                 f"{type(self).__name__} cannot run commands as another user"
@@ -234,6 +237,7 @@ class Runtime(ABC):
         runtime = copy.copy(self)
         runtime.__dict__ = self.__dict__
         runtime.user = user
+        runtime.home = home if user is not None else None
         return runtime
 
     async def alive(self) -> bool:
@@ -286,10 +290,20 @@ class Runtime(ABC):
         """
         data = script.encode() if isinstance(script, str) else script
         digest = hashlib.sha256(data).hexdigest()
-        path = f"{self.scripts_dir}/{digest}.py"
-        if digest not in self._uv_interpreters:
-            async with self._uv_script_locks.setdefault(digest, asyncio.Lock()):
-                if digest not in self._uv_interpreters:
+        # Each user needs its own writable script dir and uv environment.
+        directory = (
+            self.scripts_dir if self.user is None else f"{self.scripts_dir}-{self.user}"
+        )
+        path = f"{directory}/{digest}.py"
+        if path not in self._uv_interpreters:
+            async with self._uv_script_locks.setdefault(path, asyncio.Lock()):
+                if self.user is not None and not self._curl_ready:
+                    # Only root can install a downloader for the user's uv bootstrap.
+                    curl = await self.with_user(None).run(
+                        ["sh", "-c", _INSTALL_CURL], {}
+                    )
+                    self._curl_ready = curl.exit_code == 0
+                if path not in self._uv_interpreters:
                     tmp = f"{path}.{uuid.uuid4().hex}.tmp"
                     await self.write(tmp, data)
                     command = (
@@ -308,10 +322,8 @@ class Runtime(ABC):
                             "failed to prepare uv script: "
                             f"{result.stderr.strip()[-2000:]}"
                         )
-                    self._uv_interpreters[digest] = result.stdout.strip().splitlines()[
-                        -1
-                    ]
-        interpreter = self._uv_interpreters[digest]
+                    self._uv_interpreters[path] = result.stdout.strip().splitlines()[-1]
+        interpreter = self._uv_interpreters[path]
         if not activate:
             return [interpreter, path]
         venv = str(PurePosixPath(interpreter).parent.parent)

verifiers/v1/runtimes/prime.py

@@ -7,6 +7,7 @@ import logging
 import math
 import shlex
 import tempfile
+import uuid
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
@@ -374,13 +375,15 @@ class PrimeRuntime(Runtime):
             raise SandboxError(f"prime background launch failed: {e}") from e
 
     async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
-        if max_bytes is not None:
+        # The file API acts as the default user; a user view reads through exec.
+        if max_bytes is not None or self.user is not None:
+            reader = "cat" if max_bytes is None else f"head -c {max_bytes}"
             try:
                 # Stream binary output: execute_command buffers base64 text for the
                 # entire file. Bound the source read and the host buffer independently.
                 process = await self._client.open_process(
                     self.info.id,
-                    f"head -c {max_bytes} -- {shlex.quote(path)}",
+                    f"{reader} -- {shlex.quote(path)}",
                     working_dir=self.config.workdir,
                     env=self.process_env({}),
                     user=self.user,
@@ -388,7 +391,10 @@ class PrimeRuntime(Runtime):
                 async with contextlib.aclosing(process):
                     with io.BytesIO() as data:
                         async for chunk in process.stdout:
-                            if data.tell() + len(chunk) > max_bytes:
+                            if (
+                                max_bytes is not None
+                                and data.tell() + len(chunk) > max_bytes
+                            ):
                                 raise SandboxError(
                                     "read stream exceeded its byte limit"
                                 )
@@ -424,12 +430,26 @@ class PrimeRuntime(Runtime):
             if path.startswith("/")
             else f"{self.config.workdir.rstrip('/')}/{path}"
         )
+        if self.user is None:
+            try:
+                await self._client.upload_bytes(
+                    self.info.id, target, data, filename=PurePosixPath(target).name
+                )
+            except Exception as e:
+                raise SandboxError(f"write {path!r}: {e}") from e
+            return
+        # Uploads act as the default user: stage the bytes, then copy them in as the user.
+        root = self.with_user(None)
+        staged = f"/tmp/vf-write-{uuid.uuid4().hex}"
         try:
-            await self._client.upload_bytes(
-                self.info.id, target, data, filename=PurePosixPath(target).name
-            )
-        except Exception as e:
-            raise SandboxError(f"write {path!r}: {e}") from e
+            await root.write(staged, data)
+            await root.run(["chmod", "644", staged], {})
+            copy = 'mkdir -p "$(dirname "$1")" && cat -- "$2" > "$1"'
+            result = await self.run(["sh", "-c", copy, "sh", target, staged], {})
+        finally:
+            await root.run(["rm", "-f", staged], {})
+        if result.exit_code != 0:
+            raise SandboxError(f"write {path!r}: {result.stderr.strip()[-500:]}")
 
     def cleanup(self) -> None:
         # Synchronous atexit backstop (the async client can't run once the loop is gone): delete

{verifiers-0.3.2.dev208.dist-info → verifiers-0.3.2.dev209.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev208
+Version: 0.3.2.dev209
 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.dev208.dist-info → verifiers-0.3.2.dev209.dist-info}/RECORD

@@ -7,7 +7,7 @@ verifiers/v1/errors.py,sha256=nNabzi55J5aHmAmW9UHZVpI7kcBfy4Xcyt4cQthZbM8,5875
 verifiers/v1/graph.py,sha256=LW0pJRxCCOXZa2KwB0edHIIqmRrzLFBDNyEeOFVskl8,41502
 verifiers/v1/harness.py,sha256=4hnAh7tjiXfXoEYAzn8XhHy8sJ3PhZ0Tti5VqwxUQDs,16251
 verifiers/v1/judge.py,sha256=uq9Ddm_le_m-YIMO8AyLr4AbuQicnZamfenzsiXc95c,10466
-verifiers/v1/rollout.py,sha256=kYJMreIYzhyZicogMyvltqsdJqK9vQsc2EbK_FidWxA,29647
+verifiers/v1/rollout.py,sha256=Az7nXs66Av4SuNkloDAQkz6V9v9iys63nm3h6N2Z2uI,30072
 verifiers/v1/semantic.py,sha256=tX8FYEceuMYauuB3Bc8jLDMS2eR06JjLjTo66R190Fg,4053
 verifiers/v1/session.py,sha256=p3Rm0MU-6fPsJLjQcIMg-NOIV-8_tsqcXNTftJ94brY,28555
 verifiers/v1/state.py,sha256=EckF2bWp-vV4b1jYJ9sLI5xrfGuI5spIgYYwW926toI,595
@@ -120,7 +120,7 @@ verifiers/v1/harnesses/terminus_2/program.py,sha256=X8MZdyItU3gbXGXnGOlJ9LWcUTnq
 verifiers/v1/harnesses/utils/__init__.py,sha256=eTS-Ft2HwoLiYn5u1t_KueLmaZB_W12cdYmcVsE-G5A,364
 verifiers/v1/harnesses/utils/compaction.py,sha256=DeY6CYLEsv7-vJm26sT2mRaPHu3W2ywiZhvFr_pi6Hg,10495
 verifiers/v1/harnesses/utils/core.py,sha256=29Usc55cbLQE0vA8y05yk06sbjJMwYjOo2TmdwjPLE8,20397
-verifiers/v1/harnesses/utils/install.py,sha256=BDkkUVZ1brSzCrbQOvMO5mVIE2DsV2pE7rTC5yROYUw,2992
+verifiers/v1/harnesses/utils/install.py,sha256=20YFtGZ9cNViHffeI11OJrhJ6_y49gPEHIhs9VUn2FY,3458
 verifiers/v1/harnesses/utils/launch.py,sha256=Kg6x4Fl5y48pSgPiupSBj5ehQkkupk5vihUUvHtpcO8,2894
 verifiers/v1/harnesses/utils/mcp.py,sha256=EtDraHEqgsOB6xKvcF2z9C6HlQyKoST0ZDvmy47NWgM,7450
 verifiers/v1/interception/__init__.py,sha256=5Kvo7tcBUVaa65s9A1NiOH3CPpzw-P5btXwxB4Nbbvs,4251
@@ -138,17 +138,17 @@ verifiers/v1/judges/reference.txt,sha256=Ej35kGXiT2uJ0LcHIeez49rCS_9uHmCQKoVdn93
 verifiers/v1/judges/rubric.py,sha256=HGQYI3xdq8I84Ce0_sDeNgk5JM597es8rOVPipjCyxU,12025
 verifiers/v1/judges/rubric.txt,sha256=3KA2ZeYYdcDweJhUGopxu9EFgARhu2aWft5S5cj8Bc8,323
 verifiers/v1/mcp/__init__.py,sha256=pm8ZWBiL1q1tY4wHvJzM_QrZ9oR8aGm-bIRWiRJsgHI,408
-verifiers/v1/mcp/launch.py,sha256=r2j1hxMCZtOOjbOFBCZpt1_Zpo56e83HFMg_4sB_kA4,25916
+verifiers/v1/mcp/launch.py,sha256=a_hlziAC5L9I10fXqigGC1d32hBqbA6oSEuupp6mlZY,27319
 verifiers/v1/mcp/server.py,sha256=Jqi8OMT8DnoZegXqM3UNNRzhVnbdrPEwx0DjOJo_K2A,13256
 verifiers/v1/mcp/toolset.py,sha256=G2wzNdEMGLXoQUcrwF0TartJkqokNPI3o7YUOAaaa6U,1007
 verifiers/v1/runtimes/__init__.py,sha256=zOG9BYsK19VRNqvggqh3f6g1_UGIq7VjIBcK8kDlmnQ,3515
 verifiers/v1/runtimes/apptainer.py,sha256=Ru9QJna_l0goIzg71G-4RU_D-7wZUNz139S5TEvbzog,8211
-verifiers/v1/runtimes/base.py,sha256=8t_cYcJaps3zeCrUyFLQgisJljTd0vp0gL-ZwF0Iqok,19233
+verifiers/v1/runtimes/base.py,sha256=5tRDqGGnYvpy2qDa-V6K5EuwLKjEeI9U4gZV_8TJQZE,19947
 verifiers/v1/runtimes/container.py,sha256=_hNhGOo1Zvorj7THSj2UrZTkgewySUVJe4Kd777-QnI,12563
 verifiers/v1/runtimes/e2b.py,sha256=yBeocAutsv2l5x-C5IMqrlgBz6Cb-t6vWbX4qTjlztE,30306
 verifiers/v1/runtimes/limiters.py,sha256=rOfQJcMdYcLSKq8AL9O09BfGOLqpYmNgrCxXXNcHLmU,2849
 verifiers/v1/runtimes/modal.py,sha256=ZHA4vtNIZwTV-bnVUlambgc8l34j_ZulvtrwvvkE2Kg,17945
-verifiers/v1/runtimes/prime.py,sha256=hGjkR8KsBy1OiUeJwcgmN8-twKnCVKk5IkUvm3-eWbs,19827
+verifiers/v1/runtimes/prime.py,sha256=EzKfjtBIfH8ehjrvOI4khm6BIEZ87r84B5gmgFJQvU4,20836
 verifiers/v1/runtimes/subprocess.py,sha256=vnGVAI3J7pYmRei4MQ7MN4nb8SglLi70NtVTINMPVvQ,8855
 verifiers/v1/runtimes/docker/__init__.py,sha256=QoFOTMgRjoWD--O25Jsft9eD2vjcrMpJQyhfQXqWraI,21828
 verifiers/v1/runtimes/docker/egress.py,sha256=wtKWTL2_zFidxMR7lDRmfevQlOsl2Iyk88ebdO4Kqqw,24566
@@ -196,8 +196,8 @@ verifiers/v1/utils/scope.py,sha256=bzUEiWDOVdbj7dXOwGOlzsQ_-Xu0j9NR5TalQB-8TS8,8
 verifiers/v1/utils/score.py,sha256=493yJVMw8teCu9JxapxMFPFzI0hNUqdo0Y2nGW4kckk,6200
 verifiers/v1/utils/trace_store.py,sha256=RsCDonGR-bs-tvEstcppiJm3jFmAdIiG83fA5KtCbAw,2801
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.3.2.dev208.dist-info/METADATA,sha256=-39HRF8OYwWEEeAQQnPQ3eObdXV3Dqv6PE-9gz-1ATo,4228
-verifiers-0.3.2.dev208.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-verifiers-0.3.2.dev208.dist-info/entry_points.txt,sha256=iugElcdWPKbQM7uFF0lZ8iUpHsNr17-BwEAAjJWxV3U,259
-verifiers-0.3.2.dev208.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.3.2.dev208.dist-info/RECORD,,
+verifiers-0.3.2.dev209.dist-info/METADATA,sha256=xpcOGyiLj_NTlSRM6TSHVPHgJwfDRzRQZrgvuR3PwuA,4228
+verifiers-0.3.2.dev209.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+verifiers-0.3.2.dev209.dist-info/entry_points.txt,sha256=iugElcdWPKbQM7uFF0lZ8iUpHsNr17-BwEAAjJWxV3U,259
+verifiers-0.3.2.dev209.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.3.2.dev209.dist-info/RECORD,,