verifiers 0.1.15.dev165__tar.gz → 0.1.15.dev166__tar.gz

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev165
+Version: 0.1.15.dev166
 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.1.15.dev165 → verifiers-0.1.15.dev166}/tests/test_environment.py

@@ -673,8 +673,8 @@ class TestMaybeRetry:
         rollout_outputs = outputs["outputs"]
         assert env.call_counts[0] == 1  # No retries for non-retryable error
         assert rollout_outputs[0].get("error") is not None
-        error_info = rollout_outputs[0]["error"]
-        assert "ToolError" == error_info["error"]
+        error_data = rollout_outputs[0]["error"]
+        assert "ToolError" == error_data["error"]
 
     @pytest.mark.asyncio
     async def test_error_in_state_after_max_retries_exhausted(
@@ -694,8 +694,8 @@ class TestMaybeRetry:
         rollout_outputs = outputs["outputs"]
         assert env.call_counts[0] == 3  # 1 initial + 2 retries
         assert rollout_outputs[0].get("error") is not None
-        error_info = rollout_outputs[0]["error"]
-        assert "InfraError" == error_info["error"]
+        error_data = rollout_outputs[0]["error"]
+        assert "InfraError" == error_data["error"]
 
 
 class TestEmptyModelResponseErrors:

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/tests/test_v1_config_extension.py

@@ -1156,12 +1156,13 @@ def test_lifecycle_fields_are_framework_managed() -> None:
     task = Task({"prompt": [{"role": "user", "content": "hi"}]}).freeze()
     state = vf.State.for_task(task)
     assert state.uses_v1_contract is True
+    error = vf.Error("boom")
 
     for key, value in {
         "is_completed": True,
         "stop_condition": "done",
         "is_truncated": True,
-        "error": {"message": "boom"},
+        "error": error,
     }.items():
         assert State({key: value})[key] == value
         with pytest.raises(RuntimeError, match="framework-managed"):
@@ -1188,12 +1189,14 @@ def test_lifecycle_fields_are_framework_managed() -> None:
     state._set_completed(True)
     state._set_stop_condition("done")
     state._set_truncated(True)
-    state._set_error({"message": "boom"})
+    with pytest.raises(TypeError, match="vf.Error"):
+        state._set_error(cast(Any, {"message": "boom"}))
+    state._set_error(error)
 
     assert state["is_completed"] is True
     assert state["stop_condition"] == "done"
     assert state["is_truncated"] is True
-    assert state["error"] == {"message": "boom"}
+    assert state["error"] is error
 
 
 def test_toolsets_config_accepts_addressable_map_and_fn_tables() -> None:

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/tests/test_v1_runtime_lifecycle.py

@@ -1646,14 +1646,19 @@ def test_sandbox_program_patch_cannot_set_lifecycle_fields() -> None:
     patch = {
         "stop_condition": "no_tools",
         "is_truncated": True,
-        "error": {"message": "handled"},
+        "error": vf.ErrorData(
+            error="SandboxError",
+            message="handled",
+            error_chain_repr="SandboxError('handled')",
+            error_chain_str="SandboxError",
+        ),
     }
     apply_internal_state_patch(state, patch, mode="base")
 
     assert patch == {}
     assert state["stop_condition"] == "no_tools"
     assert state["is_truncated"] is True
-    assert state["error"] == {"message": "handled"}
+    assert isinstance(state["error"], vf.SandboxError)
 
 
 def test_program_channels_mcp_injects_proxy_into_sandbox_program() -> None:

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/envs/experimental/cli_agent_env.py

@@ -717,7 +717,7 @@ class CliAgentEnv(SandboxMixin, vf.MultiTurnEnv):
         num_turns = len(state.get("trajectory", []))
         stop_condition = state.get("stop_condition", "unknown")
         error = state.get("error")
-        error_info = (
+        error_summary = (
             f"{type(error).__name__}: {truncate(str(error), 80)}" if error else None
         )
         exit_code = state.get("agent_exit_code")
@@ -741,8 +741,8 @@ class CliAgentEnv(SandboxMixin, vf.MultiTurnEnv):
         ]
         if timed_out:
             parts.append("timed_out=True")
-        if error_info:
-            parts.append(f"error={error_info}")
+        if error_summary:
+            parts.append(f"error={error_summary}")
         self.logger.info(" | ".join(parts))
 
     @vf.cleanup

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/types.py

@@ -17,6 +17,8 @@ from typing import (
     cast,
 )
 
+from anthropic import Anthropic, AsyncAnthropic
+from openai import AsyncOpenAI, OpenAI
 from pydantic import (
     AliasChoices,
     BaseModel,
@@ -26,6 +28,8 @@ from pydantic import (
     field_validator,
 )
 
+from verifiers.errors import Error
+
 if TYPE_CHECKING:
     from anthropic.types import RedactedThinkingBlock
     from anthropic.types import ThinkingBlock as AnthropicThinkingBlock
@@ -33,7 +37,6 @@ if TYPE_CHECKING:
     from renderers import RendererConfig
 
     from verifiers.clients import Client
-    from verifiers.errors import Error
 else:
     RedactedThinkingBlock = Any
     AnthropicThinkingBlock = Any
@@ -72,6 +75,7 @@ EndpointApi = Literal[
     "openai_responses",
     "anthropic_messages",
 ]
+EndpointClient: TypeAlias = AsyncOpenAI | OpenAI | AsyncAnthropic | Anthropic
 MessageType = Literal["chat", "completion"]  # deprecated
 
 
@@ -388,8 +392,9 @@ class RolloutTiming(CustomBaseModel):
         )
 
 
-class ErrorInfo(TypedDict):
+class ErrorData(TypedDict):
     error: str
+    message: str
     error_chain_repr: str
     error_chain_str: str
 
@@ -420,7 +425,7 @@ class RolloutOutput(dict):
     # Optional fields
     answer: str
     info: Info
-    error: ErrorInfo | None
+    error: ErrorData | None
     stop_condition: str | None
     trajectory: list["TrajectoryStep"]
     tool_defs: list[Tool]
@@ -489,7 +494,7 @@ class State(dict):
     advantage: float | None
     metrics: dict[str, float] | None
     timing: RolloutTiming | None
-    error: "Error | ErrorInfo | None"
+    error: Error | None
     usage: TokenUsage | None
     usage_tracker: object
     _vf_state_contract: Literal["legacy", "v1"]
@@ -589,7 +594,9 @@ class State(dict):
     def _set_completed(self, value: bool = True) -> None:
         self._set_internal("is_completed", value)
 
-    def _set_error(self, value: Any) -> None:
+    def _set_error(self, value: Error | None) -> None:
+        if value is not None and not isinstance(value, Error):
+            raise TypeError("state.error must be a vf.Error or None.")
         self._set_internal("error", value)
 
     def _set_stop_condition(
@@ -656,7 +663,7 @@ class State(dict):
         api: EndpointApi | ClientType = "chat_completions",
         *,
         sync: bool = False,
-    ) -> object:
+    ) -> EndpointClient:
         from verifiers.v1.utils.endpoint_utils import client_from_state
 
         return client_from_state(self, api, sync=sync)
@@ -848,9 +855,17 @@ class State(dict):
 
     def finalize(self) -> "State":
         self.strip_runtime_handles()
+        self.serialize_error()
         self.assert_serializable()
         return self
 
+    def serialize_error(self) -> None:
+        error = self.get("error")
+        if isinstance(error, Error):
+            from verifiers.utils.error_utils import error_data
+
+            self._set_internal("error", error_data(error))
+
     @classmethod
     def _legacy_for_task(cls, task: Mapping[str, Any]) -> "State":
         state = cls(

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/utils/async_utils.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel
 
 import verifiers as vf
 from verifiers.utils.error_utils import ErrorChain
-from verifiers.utils.error_utils import error_info_to_exception
+from verifiers.utils.error_utils import error_data_to_exception
 from verifiers.utils.logging_utils import print_time
 
 logger = logging.getLogger(__name__)
@@ -168,7 +168,7 @@ def maybe_retry(
             if err and any(isinstance(err, err_type) for err_type in error_types):
                 raise err
             if isinstance(err, Mapping):
-                retry_error = error_info_to_exception(err, error_types)
+                retry_error = error_data_to_exception(err, error_types)
                 if retry_error is not None:
                     raise retry_error
         elif isinstance(result, list):
@@ -177,7 +177,7 @@ def maybe_retry(
                 if err and any(isinstance(err, err_type) for err_type in error_types):
                     raise err
                 if isinstance(err, Mapping):
-                    retry_error = error_info_to_exception(err, error_types)
+                    retry_error = error_data_to_exception(err, error_types)
                     if retry_error is not None:
                         raise retry_error
 

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/utils/env_utils.py

@@ -4,7 +4,15 @@ import logging
 import sys
 from collections.abc import Mapping
 from types import ModuleType, UnionType
-from typing import Callable, Union, cast, get_args, get_origin, get_type_hints
+from typing import (
+    Callable,
+    TypeAlias,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from pydantic import BaseModel
 from verifiers.envs.environment import Environment
@@ -12,8 +20,13 @@ from verifiers.utils.config_utils import MissingKeyError
 from verifiers.v1.env import Env, EnvConfig
 from verifiers.v1.harness import Harness, HarnessConfig
 from verifiers.v1.taskset import Taskset, TasksetConfig
+from verifiers.v1.types import ConfigData, ConfigValue
 from verifiers.v1.utils.config_utils import coerce_config, explicit_config_data
 
+EnvConfigLoadData: TypeAlias = dict[str, ConfigValue | BaseModel]
+EnvConfigChildInput: TypeAlias = ConfigData | EnvConfigLoadData
+EnvConfigInput: TypeAlias = EnvConfig | ConfigData
+
 
 def load_environment(env_id: str, **env_args) -> Environment:
     logger = logging.getLogger("verifiers.utils.env_utils")
@@ -127,7 +140,7 @@ def caller_module() -> ModuleType:
 def load_taskset(
     env_id: str | None = None,
     *,
-    config: TasksetConfig | Mapping[str, object] | None = None,
+    config: TasksetConfig | ConfigData | None = None,
 ) -> Taskset:
     module = caller_module() if env_id is None else import_env_module(env_id)
     return load_taskset_from_module(module, config=config)
@@ -136,7 +149,7 @@ def load_taskset(
 def load_harness(
     env_id: str | None = None,
     *,
-    config: HarnessConfig | Mapping[str, object] | None = None,
+    config: HarnessConfig | ConfigData | None = None,
 ) -> Harness:
     module = caller_module() if env_id is None else import_env_module(env_id)
     return load_harness_from_module(module, config=config)
@@ -145,7 +158,7 @@ def load_harness(
 def load_taskset_from_module(
     module: ModuleType,
     *,
-    config: TasksetConfig | Mapping[str, object] | None = None,
+    config: TasksetConfig | ConfigData | None = None,
 ) -> Taskset:
     factory = getattr(module, "load_taskset", None)
     if factory is None:
@@ -170,7 +183,7 @@ def load_taskset_from_module(
 def load_harness_from_module(
     module: ModuleType,
     *,
-    config: HarnessConfig | Mapping[str, object] | None = None,
+    config: HarnessConfig | ConfigData | None = None,
 ) -> Harness:
     factory = getattr(module, "load_harness", None)
     if factory is None:
@@ -260,11 +273,11 @@ def env_config_type(annotation: object) -> type[EnvConfig] | None:
 def load_env_config(
     module: ModuleType,
     config_type: type[EnvConfig],
-    value: object,
+    value: EnvConfigInput,
     *,
     child_types: Mapping[str, type[BaseModel]] | None = None,
 ) -> EnvConfig:
-    data: dict[str, object]
+    data: EnvConfigLoadData
     if isinstance(value, config_type):
         data = dict(explicit_config_data(value))
     elif isinstance(value, BaseModel):
@@ -275,7 +288,7 @@ def load_env_config(
     elif not isinstance(value, Mapping):
         raise TypeError("load_environment config must be a mapping or EnvConfig.")
     else:
-        data = dict(explicit_config_data(value))
+        data = dict(value)
     resolved_child_types = (
         env_config_child_types(module, config_type, data)
         if child_types is None
@@ -293,6 +306,8 @@ def load_env_config(
             continue
         if child is None:
             raise TypeError(f"config.{field_name} cannot be None.")
+        if not isinstance(child, BaseModel | dict):
+            raise TypeError(f"config.{field_name} must be a mapping or config object.")
         data[field_name] = child_type.model_validate(explicit_config_data(child))
     config = config_type.model_validate(data)
     for field_name, child_type in resolved_child_types.items():
@@ -308,7 +323,7 @@ def load_env_config(
 def env_config_child_types(
     module: ModuleType,
     config_type: type[EnvConfig],
-    value: Mapping[str, object] | None = None,
+    value: EnvConfigChildInput | None = None,
 ) -> dict[str, type[BaseModel]]:
     child_types: dict[str, type[BaseModel]] = {}
     for field_name, id_field, factory_name, base_type in (

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/utils/error_utils.py

@@ -1,8 +1,7 @@
-from collections.abc import Mapping
-from typing import Callable, cast
+from typing import Callable, TypeGuard, cast
 
 import verifiers as vf
-from verifiers.types import ErrorInfo
+from verifiers.types import ErrorData
 
 
 def get_error_chain(
@@ -56,22 +55,72 @@ class ErrorChain:
         return " -> ".join([repr(e) for e in self.chain])
 
 
-def error_info(error: BaseException) -> ErrorInfo:
+def error_data(error: BaseException) -> ErrorData:
     error_chain = ErrorChain(error)
-    return ErrorInfo(
+    return ErrorData(
         error=type(error).__name__,
+        message=str(error) or type(error).__name__,
         error_chain_repr=repr(error_chain),
         error_chain_str=str(error_chain),
     )
 
 
-def error_info_to_exception(
-    error: Mapping[str, object],
+def is_error_data(value: object) -> TypeGuard[ErrorData]:
+    expected = {"error", "message", "error_chain_repr", "error_chain_str"}
+    if not isinstance(value, dict):
+        return False
+    match value:
+        case {
+            "error": str(),
+            "message": str(),
+            "error_chain_repr": str(),
+            "error_chain_str": str(),
+        }:
+            return set(value) == expected
+    return False
+
+
+def validate_error_data(value: object) -> ErrorData:
+    if not is_error_data(value):
+        raise TypeError(
+            "ErrorData must contain string error, message, error_chain_repr, "
+            "and error_chain_str fields."
+        )
+    return value
+
+
+def error_data_to_exception(
+    error: ErrorData,
     error_types: tuple[type[Exception], ...],
 ) -> Exception | None:
-    chain = str(error.get("error_chain_str") or error.get("error") or "")
-    detail = str(error.get("error_chain_repr") or error.get("error") or "")
+    chain = error["error_chain_str"] or error["error"]
+    detail = error["error_chain_repr"] or error["error"]
     for error_type in error_types:
         if error_type.__name__ in chain:
             return error_type(detail)
     return None
+
+
+def error_from_data(error: ErrorData) -> vf.Error:
+    exception = error_data_to_exception(error, vf_error_types())
+    if isinstance(exception, vf.Error):
+        return exception
+    detail = error["error_chain_repr"] or error["error"]
+    return vf.Error(detail)
+
+
+def vf_error_types() -> tuple[type[vf.Error], ...]:
+    return (
+        vf.BrowserSandboxError,
+        vf.SandboxError,
+        vf.TunnelError,
+        vf.InfraError,
+        vf.EmptyModelResponseError,
+        vf.InvalidModelResponseError,
+        vf.ModelError,
+        vf.ToolParseError,
+        vf.ToolCallError,
+        vf.ToolError,
+        vf.OverlongPromptError,
+        vf.Error,
+    )

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/utils/logging_utils.py

@@ -10,7 +10,7 @@ from rich.table import Table
 from rich.text import Text
 
 from verifiers.errors import Error
-from verifiers.types import ErrorInfo, Messages
+from verifiers.types import ErrorData, Messages
 from verifiers.utils.error_utils import ErrorChain
 
 LOGGER_NAME = "verifiers"
@@ -156,7 +156,7 @@ def quiet_verifiers():
 def print_prompt_completions_sample(
     prompts: list[Messages],
     completions: list[Messages],
-    errors: list[Error | ErrorInfo | None],
+    errors: list[Error | ErrorData | None],
     rewards: list[float],
     step: int,
     num_samples: int = 1,

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/utils/save_utils.py

@@ -13,7 +13,6 @@ from pydantic import BaseModel
 
 from verifiers.types import (
     ClientConfig,
-    ErrorInfo,
     GenerateMetadata,
     GenerateOutputs,
     Response,
@@ -23,7 +22,7 @@ from verifiers.types import (
     TokenUsage,
     Tool,
 )
-from verifiers.utils.error_utils import ErrorChain
+from verifiers.utils.error_utils import error_data, validate_error_data
 from verifiers.utils.message_utils import (
     sanitize_tool_calls,
     serialize_messages_for_output,
@@ -280,26 +279,12 @@ def state_to_output(
             serialize_messages_for_output(completion)
         )
         output["completion"] = output_completion
-    # use repr for error
     error = state.get("error")
     if error is not None:
-        if isinstance(error, Mapping) and {
-            "error",
-            "error_chain_repr",
-            "error_chain_str",
-        } <= set(error):
-            output["error"] = ErrorInfo(
-                error=str(error["error"]),
-                error_chain_repr=str(error["error_chain_repr"]),
-                error_chain_str=str(error["error_chain_str"]),
-            )
+        if isinstance(error, BaseException):
+            output["error"] = error_data(error)
         else:
-            error_chain = ErrorChain(cast(BaseException, error))
-            output["error"] = ErrorInfo(
-                error=type(error).__name__,
-                error_chain_repr=repr(error_chain),
-                error_chain_str=str(error_chain),
-            )
+            output["error"] = validate_error_data(error)
         output["error_chain"] = output["error"]["error_chain_repr"]
         output["long_error_chain"] = output["error"]["error_chain_str"]
     # only include optional fields if non-empty

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/v1/harness.py

@@ -15,7 +15,6 @@ from verifiers.types import (
     ToolMessage,
 )
 from verifiers.utils.async_utils import maybe_call_with_named_args
-from verifiers.utils.error_utils import error_info
 from verifiers.utils.message_utils import normalize_messages
 from verifiers.utils.response_utils import parse_response_message
 from verifiers.utils.tool_utils import is_valid_tool_content_parts
@@ -277,6 +276,7 @@ class Harness(RuntimeOwnerMixin[ConfigT], Generic[ConfigT]):
                 else:
                     state.strip_runtime_handles()
             elif completed:
+                state.serialize_error()
                 state.assert_serializable()
             log_rollout_finish(state)
         return state
@@ -287,7 +287,7 @@ class Harness(RuntimeOwnerMixin[ConfigT], Generic[ConfigT]):
             state._set_truncated(True)
             state._set_stop_condition("prompt_too_long", overwrite=True)
             return
-        state._set_error(error_info(error))
+        state._set_error(error)
         state._set_stop_condition("has_error", overwrite=True)
 
     async def score_group(self, tasks: list[Task], states: list[State]) -> list[State]:

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/v1/model.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, TypeAlias, cast
 
 from verifiers.types import ClientConfig, SamplingArgs
 
@@ -28,7 +28,10 @@ class ModelConfig(Config):
         raise TypeError("model.client must resolve to a Client or ClientConfig.")
 
 
-def model_config_from_value(value: object = None) -> ModelConfig:
+ModelConfigSource: TypeAlias = ModelConfig | str | ConfigData | None
+
+
+def model_config_from_value(value: ModelConfigSource = None) -> ModelConfig:
     if isinstance(value, ModelConfig):
         return value
     if isinstance(value, str):
@@ -40,7 +43,7 @@ def model_config_from_value(value: object = None) -> ModelConfig:
     raise TypeError("model must be a string or mapping.")
 
 
-def model_config_data(value: object = None) -> ConfigData:
+def model_config_data(value: ModelConfigSource = None) -> ConfigData:
     return cast(
         ConfigData, model_config_from_value(value).model_dump(exclude_none=True)
     )

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/v1/program.py

@@ -277,8 +277,6 @@ def program_list_items(
         return []
     if isinstance(value, list):
         return cast(list[ProgramValue], list(value))
-    if isinstance(value, tuple):
-        return cast(list[ProgramValue], list(value))
     if isinstance(value, str) or isinstance(value, dict):
         return [cast(ProgramValue, value)]
     raise TypeError(f"{field_name} must be a string, mapping, or list.")

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/v1/runtime.py

@@ -1730,7 +1730,7 @@ class Runtime:
                 source_root = binding_source_root(source)
                 validate_binding_source(source, f"User binding {name!r}")
                 if source_root == "objects":
-                    object_name = binding_object_name(source)
+                    object_name = binding_object_name(cast(str, source))
                     if object_name not in user.objects:
                         raise KeyError(
                             f"User binding {name!r} references unknown User object "
@@ -1778,7 +1778,7 @@ class Runtime:
             )
             source_root = binding_source_root(source)
             if source_root == "objects":
-                object_name = binding_object_name(source)
+                object_name = binding_object_name(cast(str, source))
                 if object_name not in owner.objects:
                     raise KeyError(
                         f"Binding {binding_key!r} references unknown object "
@@ -1818,7 +1818,7 @@ class Runtime:
                     "for callable tools owned by the same Toolset."
                 )
             if source_root == "objects":
-                object_name = binding_object_name(source)
+                object_name = binding_object_name(cast(str, source))
                 if object_name not in toolset.objects:
                     raise KeyError(
                         f"Binding {binding_key!r} references unknown Toolset object "

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/v1/utils/binding_utils.py

@@ -190,8 +190,12 @@ def validate_binding_source(
     root = binding_source_root(source)
     validate_binding_source_root(root, context, allow_objects=allow_objects)
     if root == "objects":
+        if not isinstance(source, str):
+            raise TypeError(f"{context} must be a string source.")
         binding_object_name(source)
     if root in {"taskset", "harness"}:
+        if not isinstance(source, str):
+            raise TypeError(f"{context} must be a string source.")
         owner_object_name(source)
     if isinstance(source, dict):
         validate_callable_source(cast(ConfigData, source), context)
@@ -212,7 +216,7 @@ def function_name(fn: Handler) -> str:
     return name
 
 
-def binding_key_parts(key: object) -> tuple[str, str]:
+def binding_key_parts(key: str) -> tuple[str, str]:
     if not isinstance(key, str):
         raise TypeError("Binding keys must be strings.")
     target, separator, arg_name = key.partition(".")
@@ -242,7 +246,7 @@ def validate_binding_source_root(
         raise ValueError(f"{context} cannot use objects.* sources.")
 
 
-def binding_object_name(source: object) -> str:
+def binding_object_name(source: str) -> str:
     if not isinstance(source, str):
         raise TypeError("Object binding source must be a string.")
     root, separator, tail = source.partition(".")
@@ -254,7 +258,7 @@ def binding_object_name(source: object) -> str:
     return name
 
 
-def owner_object_name(source: object) -> str:
+def owner_object_name(source: str) -> str:
     if not isinstance(source, str):
         raise TypeError("Owner object binding source must be a string.")
     root, separator, tail = source.partition(".")

{verifiers-0.1.15.dev165 → verifiers-0.1.15.dev166}/verifiers/v1/utils/config_utils.py

@@ -31,7 +31,7 @@ _CONFIG_REF_MODULE: ContextVar[str | None] = ContextVar(
 
 
 def explicit_config_data(
-    value: object, target: type[BaseModel] | None = None
+    value: BaseModel | ConfigData | None, target: type[BaseModel] | None = None
 ) -> ConfigData:
     if value is None:
         data: ConfigData = {}
@@ -48,7 +48,9 @@ def explicit_config_data(
     return data
 
 
-def coerce_config(config_cls: type[ConfigT], value: object = None) -> ConfigT:
+def coerce_config(
+    config_cls: type[ConfigT], value: BaseModel | ConfigData | None = None
+) -> ConfigT:
     if value is None:
         return config_cls()
     if isinstance(value, config_cls):
@@ -168,7 +170,7 @@ def resolve_config_annotation(owner_type: ConfigOwner, annotation: object) -> ob
 
 
 def resolved_config_data(
-    value: object, target: type[BaseModel] | None = None
+    value: BaseModel | ConfigData | None, target: type[BaseModel] | None = None
 ) -> ConfigData:
     if value is None:
         data: ConfigData = {}
@@ -248,7 +250,7 @@ def config_ref_parts(ref: str) -> tuple[str, str]:
 
 
 @contextmanager
-def config_ref_context(config: object) -> Iterator[None]:
+def config_ref_context(config: BaseModel | ConfigData | None) -> Iterator[None]:
     module_name = config_ref_module(config)
     if module_name is None:
         yield
@@ -260,7 +262,7 @@ def config_ref_context(config: object) -> Iterator[None]:
         _CONFIG_REF_MODULE.reset(token)
 
 
-def config_ref_module(config: object) -> str | None:
+def config_ref_module(config: BaseModel | ConfigData | None) -> str | None:
     if isinstance(config, BaseModel):
         module_name = type(config).__module__
         if module_name not in FRAMEWORK_CONFIG_MODULES: