verifiers 0.3.1.dev12__tar.gz → 0.3.1.dev13__tar.gz

{verifiers-0.3.1.dev12 → verifiers-0.3.1.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.3.1.dev12
+Version: 0.3.1.dev13
 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.1.dev12 → verifiers-0.3.1.dev13}/pyproject.toml

@@ -178,19 +178,19 @@ prime-pydantic-config = false
 renderers = false
 
 [project.scripts]
-vf-eval = "verifiers.scripts.eval:main"
 eval = "verifiers.v1.cli.eval.main:main"
 validate = "verifiers.v1.cli.validate:main"
 debug = "verifiers.v1.cli.debug:main"
 replay = "verifiers.v1.cli.replay:main"
 init = "verifiers.v1.cli.init:main"
 gepa = "verifiers.v1.cli.gepa:main"
-vf-gepa = "verifiers.scripts.gepa:main"
-vf-init = "verifiers.scripts.init:main"
-vf-install = "verifiers.scripts.install:main"
-vf-setup = "verifiers.scripts.setup:main"
-vf-build = "verifiers.scripts.build:main"
-vf-tui = "verifiers.scripts.tui:main"
+vf-eval = "verifiers.legacy.scripts.eval:main"
+vf-gepa = "verifiers.legacy.scripts.gepa:main"
+vf-init = "verifiers.legacy.scripts.init:main"
+vf-install = "verifiers.legacy.scripts.install:main"
+vf-setup = "verifiers.legacy.scripts.setup:main"
+vf-build = "verifiers.legacy.scripts.build:main"
+vf-tui = "verifiers.legacy.scripts.tui:main"
 
 # hatchling configuration
 [tool.hatch.version]

{verifiers-0.3.1.dev12 → verifiers-0.3.1.dev13}/tests/test_imports.py

@@ -50,8 +50,9 @@ class TestImports:
 
     def test_lazy_imports_work(self):
         """Test that lazy imports work correctly."""
-        # Dynamically detect lazy imports by checking verifiers module
-        lazy_imports = getattr(verifiers, "_LAZY_IMPORTS", {})
+        # The lazy table lives on the legacy package; the root forwards its names.
+        lazy_imports = verifiers.legacy._LAZY_IMPORTS
+        assert lazy_imports, "legacy lazy-import table is empty"
 
         for name in lazy_imports.keys():
             assert name in verifiers.__all__, f"Lazy import {name} not in __all__"

verifiers-0.3.1.dev13/verifiers/__init__.py

@@ -0,0 +1,152 @@
+"""The verifiers package root.
+
+The v1 stack lives in `verifiers.v1`; the classic (v0) stack lives in
+`verifiers.legacy`. The v0 modules also answer at their historical top-level
+paths — `verifiers.envs`, `verifiers.types`, `import verifiers as vf`, ... —
+through the alias finder below, so importing this package root stays
+side-effect free (the v0 surface only loads when something touches it).
+"""
+
+import pkgutil
+import sys
+from functools import cache
+from importlib import import_module
+from importlib.abc import InspectLoader, Loader, MetaPathFinder
+from importlib.machinery import ModuleSpec
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+from importlib.util import find_spec
+from typing import TYPE_CHECKING
+
+try:
+    __version__ = _version("verifiers")
+except PackageNotFoundError:  # source tree without install metadata
+    __version__ = "0.0.0+unknown"
+
+
+@cache
+def _legacy_modules() -> frozenset:
+    """Top-level modules of `verifiers.legacy`, addressable at `verifiers.<name>`.
+    Read off the package directory, without executing its `__init__`."""
+    spec = find_spec("verifiers.legacy")
+    if spec is None or spec.submodule_search_locations is None:
+        return frozenset()
+    return frozenset(
+        module.name for module in pkgutil.iter_modules(spec.submodule_search_locations)
+    )
+
+
+class LegacyAliasFinder(MetaPathFinder, Loader):
+    """Resolve `verifiers.<v0 module>` to `verifiers.legacy.<module>`.
+
+    The loaded module is the legacy module object itself (one instance, aliased
+    in `sys.modules` under both names), so `verifiers.types.State is
+    verifiers.legacy.types.State`. Installed at the *front* of `sys.meta_path`
+    so the path finder never re-executes an aliased package's children under
+    the old name.
+    """
+
+    _prefix = "verifiers."
+    _legacy_prefix = "verifiers.legacy."
+
+    def _legacy_name(self, fullname: str) -> str:
+        return self._legacy_prefix + fullname.removeprefix(self._prefix)
+
+    def find_spec(self, fullname, path=None, target=None):
+        if not fullname.startswith(self._prefix):
+            return None
+        top = fullname.removeprefix(self._prefix).split(".", 1)[0]
+        # `legacy` first: probing the membership set resolves `verifiers.legacy`
+        # through this very finder, so it must pass through before the lookup.
+        if top in ("legacy", "v1", "cli") or top not in _legacy_modules():
+            return None
+        legacy_name = self._legacy_name(fullname)
+        try:
+            legacy_spec = find_spec(legacy_name)
+        except ModuleNotFoundError as e:
+            # A miss on the probed module itself just means the alias has no
+            # target; anything else (a missing dependency raised while the
+            # legacy package initializes) is a real failure and must surface.
+            if e.name and legacy_name.startswith(e.name):
+                legacy_spec = None
+            else:
+                raise
+        if legacy_spec is None:  # unknown submodule: fail like any missing import
+            return None
+        spec = ModuleSpec(
+            fullname,
+            self,
+            origin=legacy_spec.origin,
+            is_package=legacy_spec.submodule_search_locations is not None,
+        )
+        if legacy_spec.submodule_search_locations is not None:
+            # The real search path (not a copy), so package walkers —
+            # pkgutil.iter_modules over the alias spec, child imports through
+            # the parent's __path__ — see the legacy tree.
+            spec.submodule_search_locations = legacy_spec.submodule_search_locations
+        return spec
+
+    def create_module(self, spec):
+        module = import_module(self._legacy_name(spec.name))
+        # module_from_spec is about to stamp the alias spec onto this shared
+        # module object; stash its real identity for exec_module to restore.
+        spec.loader_state = (
+            module.__dict__.get("__spec__"),
+            module.__dict__.get("__loader__"),
+        )
+        return module
+
+    def exec_module(self, module):
+        # Restore the legacy module's own __spec__/__loader__ so reload,
+        # find_spec on the module, and importlib.resources keep seeing its
+        # real identity — the alias exists only in sys.modules.
+        alias_spec = module.__dict__.get("__spec__")
+        state = getattr(alias_spec, "loader_state", None)
+        if state:
+            real_spec, real_loader = state
+            if real_spec is not None:
+                module.__spec__ = real_spec
+                module.__loader__ = real_loader or real_spec.loader
+                if real_spec.submodule_search_locations is not None:
+                    module.__path__ = real_spec.submodule_search_locations
+
+    def _inspect_loader(self, fullname: str) -> tuple[str, InspectLoader]:
+        legacy_name = self._legacy_name(fullname)
+        spec = find_spec(legacy_name)
+        if spec is None or not isinstance(spec.loader, InspectLoader):
+            raise ImportError(
+                f"no loadable source behind alias {fullname!r}", name=fullname
+            )
+        return legacy_name, spec.loader
+
+    # runpy (`python -m verifiers.<v0 module>`) executes through the loader.
+    def get_code(self, fullname):
+        legacy_name, loader = self._inspect_loader(fullname)
+        return loader.get_code(legacy_name)
+
+    def get_source(self, fullname):
+        legacy_name, loader = self._inspect_loader(fullname)
+        return loader.get_source(legacy_name)
+
+
+if not any(isinstance(finder, LegacyAliasFinder) for finder in sys.meta_path):
+    sys.meta_path.insert(0, LegacyAliasFinder())
+
+
+def __getattr__(name: str):
+    """`vf.XMLParser`-style access forwards to the v0 surface in
+    `verifiers.legacy` (loaded on first touch). `__all__` forwards too, so
+    `from verifiers import *` keeps its pre-move meaning."""
+    if name.startswith("_") and name != "__all__":
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    legacy = import_module("verifiers.legacy")
+    return getattr(legacy, name)
+
+
+def __dir__():
+    legacy = import_module("verifiers.legacy")
+    return sorted(set(globals()) | set(legacy.__all__) | _legacy_modules())
+
+
+if TYPE_CHECKING:  # static view of the forwarded surface
+    from verifiers.legacy import *

{verifiers-0.3.1.dev12 → verifiers-0.3.1.dev13}/verifiers/legacy/__init__.py

@@ -150,7 +150,7 @@ def __getattr__(name: str):
         module, attr = _LAZY_IMPORTS[name].split(":")
         return getattr(importlib.import_module(module), attr)
     except KeyError:
-        raise AttributeError(f"module 'verifiers' has no attribute '{name}'")
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
     except ModuleNotFoundError as e:
         if name == "RendererClient":
             raise

{verifiers-0.3.1.dev12 → verifiers-0.3.1.dev13}/verifiers/legacy/utils/process_utils.py

@@ -83,16 +83,3 @@ def terminate_processes(
         t.start()
     for t in threads:
         t.join()
-
-
-def use_threading_tqdm_lock() -> None:
-    """Pin tqdm to a threading lock so it never lazily creates an `mp.RLock` a killed worker would
-    leak (a `resource_tracker` semaphore warning). No-op if tqdm isn't installed."""
-    try:
-        import threading
-
-        import tqdm
-
-        tqdm.tqdm.set_lock(threading.RLock())
-    except Exception:
-        pass

verifiers-0.3.1.dev12/verifiers/__init__.py

@@ -1,103 +0,0 @@
-"""The verifiers package root.
-
-The v1 stack lives in `verifiers.v1`; the classic (v0) stack lives in
-`verifiers.legacy`. The v0 modules keep answering at their pre-move paths —
-`verifiers.envs`, `verifiers.types`, `import verifiers as vf`, ... — through the
-alias finder below, so importing this package root stays side-effect free (the
-v0 surface only loads when something touches it).
-"""
-
-import sys
-from importlib import import_module
-from importlib.abc import Loader, MetaPathFinder
-from importlib.machinery import ModuleSpec
-from importlib.metadata import PackageNotFoundError
-from importlib.metadata import version as _version
-from importlib.util import find_spec
-from typing import TYPE_CHECKING
-
-try:
-    __version__ = _version("verifiers")
-except PackageNotFoundError:  # source tree without install metadata
-    __version__ = "0.0.0+unknown"
-
-# The v0 modules that moved under `verifiers.legacy` and stay importable at
-# their old top-level paths.
-LEGACY_MODULES = frozenset(
-    {
-        "clients",
-        "decorators",
-        "envs",
-        "errors",
-        "gepa",
-        "parsers",
-        "rubrics",
-        "scripts",
-        "serve",
-        "types",
-        "utils",
-    }
-)
-
-
-class LegacyAliasFinder(MetaPathFinder, Loader):
-    """Resolve `verifiers.<v0 module>` to `verifiers.legacy.<module>`.
-
-    The loaded module is the legacy module object itself (one instance, aliased
-    in `sys.modules` under both names), so `verifiers.types.State is
-    verifiers.legacy.types.State` and pre-move imports — including the absolute
-    ones inside the moved code — keep working. Installed at the *front* of
-    `sys.meta_path` so the path finder never re-executes an aliased package's
-    children under the old name.
-    """
-
-    _prefix = "verifiers."
-    _legacy_prefix = "verifiers.legacy."
-
-    def find_spec(self, fullname, path=None, target=None):
-        if not fullname.startswith(self._prefix) or fullname.startswith(
-            self._legacy_prefix
-        ):
-            return None
-        tail = fullname.removeprefix(self._prefix)
-        if tail.split(".", 1)[0] not in LEGACY_MODULES:
-            return None
-        try:
-            legacy_spec = find_spec(self._legacy_prefix + tail)
-        except ModuleNotFoundError:
-            legacy_spec = None
-        if legacy_spec is None:  # unknown submodule: fail like any missing import
-            return None
-        spec = ModuleSpec(
-            fullname,
-            self,
-            origin=legacy_spec.origin,
-            is_package=legacy_spec.submodule_search_locations is not None,
-        )
-        return spec
-
-    def create_module(self, spec):
-        # The already-initialized legacy module keeps its own __name__/__spec__
-        # (`module_from_spec` only fills attributes that are missing).
-        return import_module(self._legacy_prefix + spec.name.removeprefix(self._prefix))
-
-    def exec_module(self, module):
-        pass  # imported (or in progress) under its legacy name already
-
-
-if not any(isinstance(finder, LegacyAliasFinder) for finder in sys.meta_path):
-    sys.meta_path.insert(0, LegacyAliasFinder())
-
-
-def __getattr__(name: str):
-    """`vf.XMLParser`-style access forwards to the v0 surface in
-    `verifiers.legacy` (loaded on first touch). `__all__` forwards too, so
-    `from verifiers import *` keeps its pre-move meaning."""
-    if name.startswith("_") and name != "__all__":
-        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-    legacy = import_module("verifiers.legacy")
-    return getattr(legacy, name)
-
-
-if TYPE_CHECKING:  # static view of the forwarded surface
-    from verifiers.legacy import *