renderers 0.1.8.dev27__tar.gz → 0.1.8.dev29__tar.gz

{renderers-0.1.8.dev27 → renderers-0.1.8.dev29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.8.dev27
+Version: 0.1.8.dev29
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE

{renderers-0.1.8.dev27 → renderers-0.1.8.dev29}/renderers/__init__.py

@@ -59,20 +59,51 @@ from renderers.configs import (
     Qwen3VLRendererConfig,
     RendererConfig,
 )
-from renderers.deepseek_v3 import DeepSeekV3Renderer
-from renderers.default import DefaultRenderer
-from renderers.glm5 import GLM5Renderer, GLM51Renderer
-from renderers.glm45 import GLM45Renderer
-from renderers.gpt_oss import GptOssRenderer
-from renderers.kimi_k2 import KimiK2Renderer
-from renderers.kimi_k25 import KimiK25Renderer
-from renderers.laguna_xs2 import LagunaXS2Renderer
-from renderers.minimax_m2 import MiniMaxM2Renderer
-from renderers.nemotron3 import Nemotron3Renderer
-from renderers.qwen3 import Qwen3Renderer
-from renderers.qwen3_vl import Qwen3VLRenderer
-from renderers.qwen35 import Qwen35Renderer
-from renderers.qwen36 import Qwen36Renderer
+
+# Concrete renderer classes are lazy-loaded so that consumers needing
+# only the config layer (``RendererConfig`` discriminated union) don't
+# pay the ``transformers`` import cost. Each renderer module does
+# ``from transformers.tokenization_utils import PreTrainedTokenizer``
+# at module level, so eager imports here would drag ``transformers``
+# into every downstream ``import renderers``. ``__getattr__`` (PEP 562)
+# resolves the names on first attribute access, so ``from renderers
+# import DefaultRenderer`` and ``renderers.DefaultRenderer`` both work
+# transparently. ``create_renderer`` doesn't depend on these eager
+# imports — ``renderers.base._populate_registry`` lazy-imports the
+# concrete classes itself when a renderer is instantiated.
+_LAZY_RENDERERS: dict[str, str] = {
+    "DeepSeekV3Renderer": "renderers.deepseek_v3",
+    "DefaultRenderer": "renderers.default",
+    "GLM45Renderer": "renderers.glm45",
+    "GLM51Renderer": "renderers.glm5",
+    "GLM5Renderer": "renderers.glm5",
+    "GptOssRenderer": "renderers.gpt_oss",
+    "KimiK25Renderer": "renderers.kimi_k25",
+    "KimiK2Renderer": "renderers.kimi_k2",
+    "LagunaXS2Renderer": "renderers.laguna_xs2",
+    "MiniMaxM2Renderer": "renderers.minimax_m2",
+    "Nemotron3Renderer": "renderers.nemotron3",
+    "Qwen35Renderer": "renderers.qwen35",
+    "Qwen36Renderer": "renderers.qwen36",
+    "Qwen3Renderer": "renderers.qwen3",
+    "Qwen3VLRenderer": "renderers.qwen3_vl",
+}
+
+
+def __getattr__(name: str):
+    if name in _LAZY_RENDERERS:
+        import importlib
+
+        module = importlib.import_module(_LAZY_RENDERERS[name])
+        value = getattr(module, name)
+        globals()[name] = value  # cache for subsequent lookups
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals().keys()) | set(_LAZY_RENDERERS))
+
 
 __all__ = [
     "AutoRendererConfig",

{renderers-0.1.8.dev27 → renderers-0.1.8.dev29}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.8.dev27'
-__version_tuple__ = version_tuple = (0, 1, 8, 'dev27')
+__version__ = version = '0.1.8.dev29'
+__version_tuple__ = version_tuple = (0, 1, 8, 'dev29')
 
 __commit_id__ = commit_id = None

{renderers-0.1.8.dev27 → renderers-0.1.8.dev29}/renderers/parsing.py

@@ -65,30 +65,36 @@ def _coerce_arg_value(
     """Coerce a raw ``<arg_value>`` body to its declared type.
 
     Returns ``(value, used_json_fallback)``. The boolean is ``True`` only
-    when ``json.loads`` was attempted and raised, so the caller knows
-    whether to flag ``INVALID_JSON``. Returning a string verbatim
-    because the schema declared ``type: "string"`` is NOT a fallback.
+    when ``json.loads`` was attempted, raised, AND the schema doesn't
+    permit a string. Returning a string verbatim because the schema
+    permits strings is NOT a fallback.
 
     Rule (matches vLLM / SGLang reference parsers):
 
     - If the param's declared ``type`` is ``"string"`` (or single-element
       ``["string"]``), return ``text`` verbatim — never ``json.loads``.
-    - Anything else (no schema, non-string scalar, object, array, or
-      union types that include non-string): try ``json.loads`` and fall
-      back to raw ``text`` on parse failure.
-
-    Union types that include ``"string"`` alongside other types still
-    attempt ``json.loads`` first so an explicit integer / bool can
-    parse; the string branch only wins as the fallback.
+    - Otherwise try ``json.loads``. If that fails, return raw ``text``.
+      The ``used_json_fallback`` flag is ``True`` only when the schema
+      does NOT permit a string — i.e. the fallback is truly suspect.
+
+    Union types (``anyOf``/``oneOf``) that include ``"string"`` alongside
+    other types still attempt ``json.loads`` first so an explicit
+    integer / bool can parse; the string branch wins as fallback, and
+    landing there is expected — not a malformed-JSON signal.
     """
+    string_is_allowed = False
     if param_schema is not None:
         declared = param_schema.get("type")
         if declared == "string" or declared == ["string"]:
             return text, False
+        for branch in param_schema.get("anyOf") or param_schema.get("oneOf") or []:
+            if isinstance(branch, dict) and branch.get("type") == "string":
+                string_is_allowed = True
+                break
     try:
         return json.loads(text), False
     except (json.JSONDecodeError, ValueError):
-        return text, True
+        return text, not string_is_allowed
 
 
 def _find(ids: list[int], target: int, start: int = 0) -> int:

{renderers-0.1.8.dev27 → renderers-0.1.8.dev29}/tests/test_tool_arg_type_preservation.py

@@ -137,3 +137,75 @@ def test_string_arg_preserves_type(model, renderer_name, renderer, args):
     assert got == args, (
         f"{model}: tool-arg type drift — sent {args!r}, parser returned {got!r}"
     )
+
+
+# Schemas where ``string`` is one branch of a union (``anyOf`` / ``oneOf``).
+# These are common in practice — e.g. ``form_input.value: str | bool`` in
+# Pydantic serialises to ``{"anyOf": [{"type": "string"}, {"type": "boolean"}]}``.
+# Without the union-aware check, the XML parser's ``json.loads`` falls back
+# to raw text for bare strings, but flags the call ``INVALID_JSON`` because
+# no top-level ``type`` key declared a string — silently dropping otherwise
+# valid tool calls in the renderer client.
+UNION_WITH_STRING_SCHEMAS = [
+    pytest.param(
+        {"anyOf": [{"type": "string"}, {"type": "boolean"}]},
+        id="anyOf-string-boolean",
+    ),
+    pytest.param(
+        {"anyOf": [{"type": "string"}, {"type": "null"}]},
+        id="anyOf-string-null",
+    ),
+    pytest.param(
+        {"oneOf": [{"type": "string"}, {"type": "integer"}]},
+        id="oneOf-string-integer",
+    ),
+]
+
+
+@pytest.mark.parametrize("param_schema", UNION_WITH_STRING_SCHEMAS)
+def test_union_with_string_emits_ok_status(
+    model, renderer_name, renderer, param_schema
+):
+    """Union schemas containing ``string`` must yield ``status=OK`` when
+    the model emits a bare string. Pre-fix, ``_coerce_arg_value`` flagged
+    this as ``INVALID_JSON`` because the top-level ``type`` key was
+    absent (the string branch was under ``anyOf`` / ``oneOf``)."""
+    from renderers.base import ToolCallParseStatus
+
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "f",
+                "description": "Test tool with one union-typed parameter.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"x": param_schema},
+                    "required": ["x"],
+                },
+            },
+        }
+    ]
+    args = {"x": "abc"}
+    msg = {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+            {
+                "id": "functions.f:0",
+                "function": {"name": "f", "arguments": args},
+            }
+        ],
+    }
+    completion_ids = _extract_assistant_tokens(renderer, PROMPT, msg, tools=tools)
+    parsed = renderer.parse_response(completion_ids, tools=tools)
+
+    assert parsed.tool_calls, f"{model}: parser returned no tool_calls"
+    tc = parsed.tool_calls[0]
+    assert tc.status == ToolCallParseStatus.OK, (
+        f"{model}: union-with-string schema flagged {tc.status} on bare string"
+    )
+    got = _normalize_args(tc.arguments)
+    assert got == args, (
+        f"{model}: tool-arg drift — sent {args!r}, parser returned {got!r}"
+    )