verifiers 0.2.2.dev34__tar.gz → 0.2.2.dev35__tar.gz

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev34
+Version: 0.2.2.dev35
 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.2.2.dev34 → verifiers-0.2.2.dev35}/pyproject.toml

@@ -57,9 +57,9 @@ dependencies = [
 
 [dependency-groups]
 dev = [
-    "ruff>=0.9.0",
+    "ruff>=0.16.0",
     "pre-commit>=2.19.0",
-    "ty>=0.0.1a29,<0.0.22",
+    "ty>=0.0.63",
     "pytest>=7.0.0,<9.1.0",
     "pytest-asyncio>=0.21.0",
     "pytest-cov>=4.0.0",
@@ -135,6 +135,9 @@ scratchpad-v1 = { path = "environments/scratchpad_v1", editable = true }
 kuhn-poker-v1 = { path = "environments/kuhn_poker_v1", editable = true }
 
 [tool.uv.exclude-newer-package]
+# Bounded cutoffs for the explicitly requested tool upgrades.
+ruff = "2026-07-27"
+ty = "2026-07-27"
 # PrimeIntellect-published on PyPI (trusted publisher)
 prime-tunnel = false
 prime-sandboxes = false

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/clients/nemorl_chat_completions_client.py

@@ -108,8 +108,8 @@ def _attach_trajectory_tokens_to_prompt(
             continue
         msg = prompt[i]
         if (prompt_ids := tokens.get("prompt_ids")) is not None:
-            msg.prompt_token_ids = list(prompt_ids)
+            msg.prompt_token_ids = list(prompt_ids)  # ty:ignore[invalid-assignment]
         if (completion_ids := tokens.get("completion_ids")) is not None:
-            msg.generation_token_ids = list(completion_ids)
+            msg.generation_token_ids = list(completion_ids)  # ty:ignore[invalid-assignment]
         if (completion_logprobs := tokens.get("completion_logprobs")) is not None:
-            msg.generation_log_probs = list(completion_logprobs)
+            msg.generation_log_probs = list(completion_logprobs)  # ty:ignore[invalid-assignment]

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/clients/openai_chat_completions_client.py

@@ -233,7 +233,7 @@ class OpenAIChatCompletionsClient(
                     role="assistant",
                     content=cast(Any, normalize_content(message.content)),
                     tool_calls=cast(Any, oai_tool_calls),
-                    reasoning_content=message.reasoning_content,  # type: ignore[arg-type]
+                    reasoning_content=message.reasoning_content,  # type: ignore[arg-type]  # ty:ignore[invalid-key]
                 )
             elif isinstance(message, ToolMessage):
                 return ChatCompletionToolMessageParam(

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/clients/openai_chat_completions_token_client.py

@@ -290,7 +290,7 @@ class OpenAIChatCompletionsTokenClient(OpenAIChatCompletionsClient):
         if tool_call_ids:
             dummy_assistant: OpenAIChatMessage = ChatCompletionAssistantMessageParam(
                 role="assistant",
-                reasoning_content="",  # type: ignore[typeddict-unknown-key]
+                reasoning_content="",  # type: ignore[typeddict-unknown-key]  # ty:ignore[invalid-key]
                 tool_calls=[
                     ChatCompletionMessageFunctionToolCallParam(
                         id=tc_id,
@@ -303,7 +303,7 @@ class OpenAIChatCompletionsTokenClient(OpenAIChatCompletionsClient):
         else:
             dummy_assistant: OpenAIChatMessage = ChatCompletionAssistantMessageParam(
                 role="assistant",
-                reasoning_content="",  # type: ignore[typeddict-unknown-key]
+                reasoning_content="",  # type: ignore[typeddict-unknown-key]  # ty:ignore[invalid-key]
                 content="x",
             )
 

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/env_group.py

@@ -294,7 +294,7 @@ class EnvGroup(vf.Environment):
         return dataset
 
     @final
-    async def run_rollout(  # type: ignore[override]
+    async def run_rollout(  # type: ignore[override]  # ty:ignore[override-of-final-method]
         self,
         input: RolloutInput,
         client: Client | ClientConfig,
@@ -330,10 +330,10 @@ class EnvGroup(vf.Environment):
             state_columns,
             env.env_client,
         )
-        return _set_info_route(output, route)  # type: ignore[return-value]
+        return _set_info_route(output, route)  # type: ignore[return-value]  # ty:ignore[invalid-return-type]
 
     @final
-    async def run_group(  # type: ignore[override]
+    async def run_group(  # type: ignore[override]  # ty:ignore[override-of-final-method]
         self,
         group_inputs: list[RolloutInput],
         client: Client | ClientConfig,
@@ -342,7 +342,7 @@ class EnvGroup(vf.Environment):
         max_retries: int = 0,
         state_columns: list[str] | None = None,
         env_client: EnvClient | None = None,
-    ) -> list[vf.RolloutOutput]:
+    ) -> list[vf.RolloutOutput]:  # ty:ignore[invalid-method-override]
         target_env_client = env_client or self.env_client
         if target_env_client is not None:
             if not isinstance(client, ClientConfig):
@@ -383,7 +383,7 @@ class EnvGroup(vf.Environment):
             state_columns,
             env.env_client,
         )
-        return [_set_info_route(output, route) for output in outputs]  # type: ignore[return-value]
+        return [_set_info_route(output, route) for output in outputs]  # type: ignore[return-value]  # ty:ignore[invalid-return-type]
 
     @final
     async def rollout(
@@ -417,7 +417,7 @@ class EnvGroup(vf.Environment):
             child_input["info"] = info
         else:
             child_input.pop("info", None)
-        return env_name, child_input, route  # type: ignore[return-value]
+        return env_name, child_input, route  # type: ignore[return-value]  # ty:ignore[invalid-return-type]
 
     def _input_env_route(self, input: RolloutInput) -> tuple[str, ...]:
         info = _info_dict(input.get("info"))

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/environment.py

@@ -162,7 +162,7 @@ class Environment(ABC):
 
         if dataset is not None:
             if callable(dataset):
-                self.dataset_source: DatasetBuilder | None = cast(
+                self.dataset_source: DatasetBuilder | None = cast(  # ty:ignore[unsupported-operator]
                     DatasetBuilder, dataset
                 )
             else:
@@ -173,7 +173,7 @@ class Environment(ABC):
 
         if eval_dataset is not None:
             if callable(eval_dataset):
-                self.eval_dataset_source: DatasetBuilder | None = cast(
+                self.eval_dataset_source: DatasetBuilder | None = cast(  # ty:ignore[unsupported-operator]
                     DatasetBuilder, eval_dataset
                 )
             else:
@@ -294,7 +294,7 @@ class Environment(ABC):
                 if few_shot:
                     messages.extend(few_shot)
                 messages.append({"role": "user", "content": prompt_str})
-                return messages
+                return messages  # ty:ignore[invalid-return-type]
 
             if answer_key == "answer":
                 dataset = dataset.map(

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/experimental/composable/task.py

@@ -369,7 +369,7 @@ class TaskSet:
         try:
             from tqdm.auto import tqdm
         except ImportError:  # pragma: no cover
-            tqdm = None  # type: ignore[assignment]
+            tqdm = None  # type: ignore[assignment]  # ty:ignore[invalid-assignment]
 
         import verifiers as vf
 
@@ -521,7 +521,7 @@ class TaskSet:
                 state: State = {  # type: ignore[assignment]
                     "info": info,
                     "answer": row.get("answer", ""),
-                }
+                }  # ty:ignore[invalid-assignment]
                 try:
                     valid = await self.validate_instance(state)
                     return valid, None, state
@@ -543,7 +543,7 @@ class TaskSet:
                 state: State = {  # type: ignore[assignment]
                     "info": info,
                     "answer": row.get("answer", ""),
-                }
+                }  # ty:ignore[invalid-assignment]
                 spec = self.get_sandbox_spec(info)
                 # validate() runs without a SandboxMixin, so resolve
                 # spec.timeout_minutes=None (its "auto-derive at rollout

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/experimental/composable/tasksets/cp/test_utils.py

@@ -319,7 +319,7 @@ async def run_func_call(
                     )
                 try:
                     if isinstance(exec_outputs[0], tuple):
-                        exec_outputs = [list(x) for x in exec_outputs]
+                        exec_outputs = [list(x) for x in exec_outputs]  # ty:ignore[invalid-argument-type]
                         tmp_result = tmp_result or (
                             exec_outputs == test_case_outputs_parsed[0]
                         )

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/experimental/harbor_env/mcp.py

@@ -180,7 +180,7 @@ class HarborMCPMixin:
         for name in list(jobs):
             try:
                 pid_file = shlex.quote(self._mcp_pid_file(name))
-                await self.sandbox_client.execute_command(  # type: ignore[attr-defined]
+                await self.sandbox_client.execute_command(  # type: ignore[attr-defined]  # ty:ignore[unresolved-attribute]
                     sandbox_id,
                     f'kill -9 -"$(cat {pid_file} 2>/dev/null)" 2>/dev/null; rm -f {pid_file}',
                     working_dir=None,
@@ -203,7 +203,7 @@ class HarborMCPMixin:
                 f"MCP server {server.name!r} has no port in its URL {server.url!r}"
             )
 
-        job = await self.sandbox_client.start_background_job(  # type: ignore[attr-defined]
+        job = await self.sandbox_client.start_background_job(  # type: ignore[attr-defined]  # ty:ignore[unresolved-attribute]
             sandbox_id=sandbox_id,
             command=(
                 f"setsid sh -c {shlex.quote(command)} & "
@@ -239,7 +239,7 @@ class HarborMCPMixin:
         consecutive_failures = 0
 
         while True:
-            status = await self.sandbox_client.get_background_job(  # type: ignore[attr-defined]
+            status = await self.sandbox_client.get_background_job(  # type: ignore[attr-defined]  # ty:ignore[unresolved-attribute]
                 sandbox_id, job
             )
             if getattr(status, "completed", False):
@@ -251,7 +251,7 @@ class HarborMCPMixin:
                     f"Stderr:\n{stderr}"
                 )
 
-            result = await self.sandbox_client.execute_command(  # type: ignore[attr-defined]
+            result = await self.sandbox_client.execute_command(  # type: ignore[attr-defined]  # ty:ignore[unresolved-attribute]
                 sandbox_id, health_cmd, working_dir=None, timeout=probe_timeout
             )
             if getattr(result, "exit_code", 1) == 0:
@@ -280,7 +280,7 @@ class HarborMCPMixin:
             if consecutive_failures >= hc.retries:
                 log_tail = ""
                 try:
-                    status = await self.sandbox_client.get_background_job(  # type: ignore[attr-defined]
+                    status = await self.sandbox_client.get_background_job(  # type: ignore[attr-defined]  # ty:ignore[unresolved-attribute]
                         sandbox_id, job
                     )
                     log_tail = (getattr(status, "stderr", "") or "").strip()[-2000:]
@@ -313,7 +313,7 @@ class HarborMCPMixin:
             f"echo {shlex.quote(f'127.0.0.1 {h}')} >> /etc/hosts)"
             for h in sorted(hosts)
         )
-        result = await self.sandbox_client.execute_command(  # type: ignore[attr-defined]
+        result = await self.sandbox_client.execute_command(  # type: ignore[attr-defined]  # ty:ignore[unresolved-attribute]
             sandbox_id, statements, working_dir=None
         )
         exit_code = getattr(result, "exit_code", 0)

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/integrations/browser_env/modes/cua_mode.py

@@ -33,10 +33,10 @@ try:
     SANDBOX_AVAILABLE = True
 except ImportError:
     SANDBOX_AVAILABLE = False
-    AsyncSandboxClient = None  # type: ignore[misc, assignment]
-    CreateSandboxRequest = None  # type: ignore[misc, assignment]
-    SandboxClient = None  # type: ignore[misc, assignment]
-    APIClient = None  # type: ignore[misc, assignment]
+    AsyncSandboxClient = None  # type: ignore[misc, assignment]  # ty:ignore[invalid-assignment]
+    CreateSandboxRequest = None  # type: ignore[misc, assignment]  # ty:ignore[invalid-assignment]
+    SandboxClient = None  # type: ignore[misc, assignment]  # ty:ignore[invalid-assignment]
+    APIClient = None  # type: ignore[misc, assignment]  # ty:ignore[invalid-assignment]
 
 
 class CUAMode:
@@ -366,7 +366,7 @@ class CUAMode:
     async def _create_sandbox(self) -> str:
         """Create a new sandbox and return its ID."""
         client = await self._get_sandbox_client()
-        sandbox = await client.create(self._sandbox_request.model_copy())  # type: ignore[union-attr]
+        sandbox = await client.create(self._sandbox_request.model_copy())  # type: ignore[union-attr]  # ty:ignore[unresolved-attribute]
         self.active_sandboxes.add(sandbox.id)
         if self.logger:
             self.logger.debug(f"Created sandbox {sandbox.id}")
@@ -375,7 +375,7 @@ class CUAMode:
     async def _create_sandbox_with_retry(self) -> str:
         """Create a sandbox with retry, cleaning up orphaned sandboxes from failed attempts."""
         previous_sandbox_id: str | None = None
-        async for attempt in self.retrying:  # type: ignore[union-attr]
+        async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
             with attempt:
                 if previous_sandbox_id is not None:
                     try:
@@ -822,7 +822,7 @@ class CUAMode:
         if self._execution_mode == "local":
             # Local mode: create session via HTTP
             try:
-                async for attempt in self.retrying:  # type: ignore[union-attr]
+                async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
                     with attempt:
                         result = await self._create_session_http()
                 session_id = result.get("sessionId")
@@ -863,7 +863,7 @@ class CUAMode:
                     await self._start_server(sandbox_id)
                     await self._wait_for_server(sandbox_id)
 
-                async for attempt in self.retrying:  # type: ignore[union-attr]
+                async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
                     with attempt:
                         result = await self._create_session_curl(sandbox_id)
                 session_id = result.get("sessionId")
@@ -910,7 +910,7 @@ class CUAMode:
             # Local mode: destroy session via HTTP
             if session_id:
                 try:
-                    async for attempt in self.retrying:  # type: ignore[union-attr]
+                    async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
                         with attempt:
                             await self._destroy_session_http(session_id)
                     with self._sessions_lock:
@@ -926,7 +926,7 @@ class CUAMode:
 
             if session_id and sandbox_id:
                 try:
-                    async for attempt in self.retrying:  # type: ignore[union-attr]
+                    async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
                         with attempt:
                             await self._destroy_session_curl(session_id, sandbox_id)
                     with self._sessions_lock:
@@ -939,7 +939,7 @@ class CUAMode:
 
             if sandbox_id:
                 try:
-                    async for attempt in self.retrying:  # type: ignore[union-attr]
+                    async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
                         with attempt:
                             await self._delete_sandbox(sandbox_id)
                 except Exception as e:
@@ -968,7 +968,7 @@ class CUAMode:
                 async def _delete_with_semaphore(session_id: str):
                     async with semaphore:
                         try:
-                            async for attempt in self.retrying:  # type: ignore[union-attr]
+                            async for attempt in self.retrying:  # type: ignore[union-attr]  # ty:ignore[not-iterable]
                                 with attempt:
                                     await self._destroy_session_http(session_id)
                             with self._sessions_lock:

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/integrations/openenv_env.py

@@ -807,7 +807,7 @@ class OpenEnvEnv(vf.MultiTurnEnv):
         if len(props) == 1:
             field_name, spec = next(iter(props.items()))
             if isinstance(spec, dict) and spec.get("type") == "string":
-                return field_name
+                return field_name  # ty:ignore[invalid-return-type]
         return None
 
     def _render_observation_messages(

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/integrations/textarena_env.py

@@ -104,7 +104,7 @@ class TextArenaEnv(vf.MultiTurnEnv):
 
     async def setup_state(self, state: vf.State, **kwargs) -> vf.State:
         ta_env = await asyncio.to_thread(deepcopy, self.ta_env, self.shared_memo.copy())
-        ta_env.state.game_state["secret_word"] = state["answer"]  # type: ignore[unresolved-attribute]
+        ta_env.state.game_state["secret_word"] = state["answer"]  # type: ignore[unresolved-attribute]  # ty:ignore[unresolved-attribute]
         state["ta_env"] = ta_env
         return state
 

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/envs/tool_env.py

@@ -33,7 +33,7 @@ class ToolMonitorRubric(vf.Rubric):
             self.tool_names.remove(tool_name)
             metric_name = f"{tool_name}_calls"
             for i, func in enumerate(self.funcs):
-                if func.__name__ == metric_name:
+                if func.__name__ == metric_name:  # ty:ignore[unresolved-attribute]
                     self.funcs.pop(i)
                     self.weights.pop(i)
                     break

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/gepa/adapter.py

@@ -184,7 +184,7 @@ def _inject_system_prompt(
         if isinstance(prompt, str):
             inp_copy["prompt"] = f"{system_prompt}\n\n{prompt}"
         else:
-            prompt = [dict(m) for m in prompt]
+            prompt = [dict(m) for m in prompt]  # ty:ignore[not-iterable]
             if not prompt:
                 # Empty prompt list - just add system message
                 prompt = [{"role": "system", "content": system_prompt}]
@@ -195,7 +195,7 @@ def _inject_system_prompt(
             inp_copy["prompt"] = prompt
 
         modified.append(inp_copy)
-    return modified
+    return modified  # ty:ignore[invalid-return-type]
 
 
 def _extract_user_query(prompt: Messages) -> str:

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/rubrics/experimental/hybrid_math_rubric.py

@@ -129,7 +129,7 @@ class HybridMathRubric(vf.JudgeRubric):
         self.add_reward_func(self.correct_answer, weight=1)
 
         self.judge_model = judge_model if use_judge_fallback else None
-        self.class_objects["judge_model"] = self.judge_model
+        self.class_objects["judge_model"] = self.judge_model  # ty:ignore[invalid-assignment]
 
         # Delegate math verification to default MathRubric
         # We clear its auto-registered reward func since we manage scoring ourselves

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/rubrics/rubric.py

@@ -168,7 +168,7 @@ class Rubric:
             **self.class_objects,
         )
         for provider in self.group_score_object_providers:
-            objects.update(provider(states))
+            objects.update(provider(states))  # ty:ignore[no-matching-overload]
         return objects
 
     def task_for_state(self, state: State, resources: object | None) -> object:
@@ -203,7 +203,7 @@ class Rubric:
                 ans = float(await maybe_await(func, **merged))
             except Exception as e:
                 self.logger.error(
-                    f"Error calling reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]
+                    f"Error calling reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]  # ty:ignore[unresolved-attribute]
                 )
                 ans = 0.0
         else:
@@ -212,7 +212,7 @@ class Rubric:
                 ans = float(await maybe_await(func, **allowed))
             except Exception as e:
                 self.logger.error(
-                    f"Error calling reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]
+                    f"Error calling reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]  # ty:ignore[unresolved-attribute]
                 )
                 ans = 0.0
         return ans
@@ -248,7 +248,7 @@ class Rubric:
                 ans = await maybe_await(func, **merged)
             except Exception as e:
                 self.logger.error(
-                    f"Error calling group reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]
+                    f"Error calling group reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]  # ty:ignore[unresolved-attribute]
                 )
                 ans = [0.0] * len(states)
         else:
@@ -257,7 +257,7 @@ class Rubric:
                 ans = await maybe_await(func, **allowed)
             except Exception as e:
                 self.logger.error(
-                    f"Error calling group reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]
+                    f"Error calling group reward function {func.__name__}: {e}"  # type: ignore[unresolved-attribute]  # ty:ignore[unresolved-attribute]
                 )
                 ans = [0.0] * len(states)
         return ans
@@ -335,7 +335,7 @@ class Rubric:
             )
         rewards = RolloutScore(
             metrics={
-                func.__name__: reward
+                func.__name__: reward  # ty:ignore[unresolved-attribute]
                 for func, reward in zip(reward_funcs, reward_scores)
             },
             reward=sum(
@@ -380,7 +380,7 @@ class Rubric:
                 # GroupRewardFunc: score all states together
                 group_func = cast(GroupRewardFunc, func)
                 scores = await self._call_group_reward_func(group_func, states)
-                func_name = func.__name__
+                func_name = func.__name__  # ty:ignore[unresolved-attribute]
                 if func_name not in aggregated_metrics:
                     aggregated_metrics[func_name] = [0.0] * num_states
                 for i in range(num_states):
@@ -395,7 +395,7 @@ class Rubric:
                 ]
                 scores = await asyncio.gather(*score_tasks)
 
-                func_name = func.__name__
+                func_name = func.__name__  # ty:ignore[unresolved-attribute]
                 if func_name not in aggregated_metrics:
                     aggregated_metrics[func_name] = [0.0] * num_states
                 for i in range(num_states):

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/scripts/gepa.py

@@ -829,7 +829,7 @@ def run_gepa_optimization(
             logger.debug(f"Results saved to {run_dir}")
 
         # Set result info for final summary
-        best_prompt = result.best_candidate.get("system_prompt", "")  # type: ignore[unresolved-attribute]
+        best_prompt = result.best_candidate.get("system_prompt", "")  # type: ignore[unresolved-attribute]  # ty:ignore[unresolved-attribute]
         display.set_result(best_prompt=best_prompt, save_path=save_path)
 
     return result

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/types.py

@@ -479,7 +479,7 @@ class State(dict):
                 return input_obj[key]
         return super().__getitem__(key)
 
-    def get(self, key: str, default: Any = None) -> Any:
+    def get(self, key: str, default: Any = None) -> Any:  # ty:ignore[invalid-method-override]
         try:
             return self[key]
         except KeyError:
@@ -506,7 +506,7 @@ class State(dict):
     @overload
     def pop(self, key: str, default: _DefaultValue) -> Any | _DefaultValue: ...
 
-    def pop(self, key: str, default: Any = _MISSING) -> Any:
+    def pop(self, key: str, default: Any = _MISSING) -> Any:  # ty:ignore[invalid-method-override]
         if default is _MISSING:
             return super().pop(key)
         return super().pop(key, default)

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/utils/async_utils.py

@@ -184,7 +184,7 @@ def maybe_retry(
 
     def log_retry(retry_state: tc.RetryCallState) -> None:
         """Log a warning with the exception and the number of attempts."""
-        caller = retry_state.fn.__name__ if retry_state.fn else "unknown function"
+        caller = retry_state.fn.__name__ if retry_state.fn else "unknown function"  # ty:ignore[unresolved-attribute]
         error_chain = (
             repr(
                 ErrorChain(
@@ -203,7 +203,7 @@ def maybe_retry(
 
     def return_last_result(retry_state: tc.RetryCallState):
         """Return the last result when retries are exhausted (instead of raising)."""
-        caller = retry_state.fn.__name__ if retry_state.fn else "unknown function"
+        caller = retry_state.fn.__name__ if retry_state.fn else "unknown function"  # ty:ignore[unresolved-attribute]
         error_chain = (
             repr(
                 ErrorChain(

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/utils/eval_utils.py

@@ -424,10 +424,10 @@ def _expand_ablation(ablation: dict, global_defaults: dict) -> list[dict]:
         for key, value in zip(keys, combo):
             if key.startswith("env_args."):
                 env_key = key[len("env_args.") :]
-                config["env_args"] = {**config.get("env_args", {}), env_key: value}
+                config["env_args"] = {**config.get("env_args", {}), env_key: value}  # ty:ignore[invalid-argument-type]
             elif key.startswith("args."):
                 env_key = key[len("args.") :]
-                config["args"] = {**config.get("args", {}), env_key: value}
+                config["args"] = {**config.get("args", {}), env_key: value}  # ty:ignore[invalid-argument-type]
             else:
                 config[key] = value
         expanded.append(config)
@@ -1168,7 +1168,7 @@ async def run_evaluations(config: EvalRunConfig) -> None:
         from verifiers.utils.heartbeat import Heartbeat
 
         heart = Heartbeat(config.heartbeat_url)
-        on_progress = [lambda *_a, **_kw: asyncio.create_task(heart.beat())]
+        on_progress = [lambda *_a, **_kw: asyncio.create_task(heart.beat())]  # ty:ignore[invalid-assignment]
 
     start_time = time.time()
     all_results = await asyncio.gather(
@@ -1307,7 +1307,7 @@ async def run_evaluations_tui(
 
         on_progress: list[ProgressCallback] = [on_display_progress]
         if heart is not None:
-            on_progress.append(lambda *_a, **_kw: asyncio.create_task(heart.beat()))
+            on_progress.append(lambda *_a, **_kw: asyncio.create_task(heart.beat()))  # ty:ignore[invalid-argument-type]
 
         def on_log(message: str) -> None:
             display.update_env_state(env_idx, log_message=message)

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/utils/interception_utils.py

@@ -129,7 +129,7 @@ class InterceptionServer:
             )
             app.router.add_get(
                 "/health",
-                lambda _: web.json_response({"status": "ok"}),
+                lambda _: web.json_response({"status": "ok"}),  # ty:ignore[invalid-argument-type]
             )
 
             runner = web.AppRunner(app)

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/utils/message_utils.py

@@ -144,31 +144,31 @@ def normalize_messages(
 
 
 @overload
-def get_messages(
+def get_messages(  # ty:ignore[invalid-overload]
     messages: Sequence[MessageLike], role: Literal["assistant"]
 ) -> list[AssistantMessage]: ...
 
 
 @overload
-def get_messages(
+def get_messages(  # ty:ignore[invalid-overload]
     messages: Sequence[MessageLike], role: Literal["system"]
 ) -> list[SystemMessage]: ...
 
 
 @overload
-def get_messages(
+def get_messages(  # ty:ignore[invalid-overload]
     messages: Sequence[MessageLike], role: Literal["user"]
 ) -> list[UserMessage]: ...
 
 
 @overload
-def get_messages(
+def get_messages(  # ty:ignore[invalid-overload]
     messages: Sequence[MessageLike], role: Literal["tool"]
 ) -> list[ToolMessage]: ...
 
 
 @overload
-def get_messages(
+def get_messages(  # ty:ignore[invalid-overload]
     messages: Sequence[MessageLike], role: Literal["text"]
 ) -> list[TextMessage]: ...
 

{verifiers-0.2.2.dev34 → verifiers-0.2.2.dev35}/verifiers/utils/save_utils.py

@@ -428,7 +428,7 @@ def _read_mm_hashes(mm: object) -> dict[str, list[str]]:
         return {}
     return {
         modality: list(hs) for modality, hs in hashes.items() if isinstance(hs, list)
-    }
+    }  # ty:ignore[invalid-return-type]
 
 
 def _is_monotonic_extension(
@@ -505,7 +505,7 @@ def _diff_mm_data(mm: object, prior_hashes: dict[str, list[str]]) -> object:
         keep_idx: list[int] = []
         for i, h in enumerate(mod_hashes):
             if remaining.get(h, 0) > 0:
-                remaining[h] -= 1
+                remaining[h] -= 1  # ty:ignore[invalid-argument-type]
             else:
                 keep_idx.append(i)
         if len(keep_idx) != len(mod_hashes):