renderers 0.1.13.dev15__tar.gz → 0.1.13.dev17__tar.gz

{renderers-0.1.13.dev15 → renderers-0.1.13.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.13.dev15
+Version: 0.1.13.dev17
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE

{renderers-0.1.13.dev15 → renderers-0.1.13.dev17}/renderers/__init__.py

@@ -6,6 +6,8 @@ except ImportError:
     # installs always have it.
     __version__ = "0+unknown"
 
+from typing import TYPE_CHECKING
+
 from renderers.base import (
     MULTIMODAL_MODELS,
     ChatTemplateTokenizer,
@@ -42,7 +44,6 @@ from renderers.base import (
     template_field_names,
     trim_to_turn_close,
 )
-from renderers.client import MalformedGenerateResponseError, OverlongPromptError
 from renderers.configs import (
     AutoRendererConfig,
     BaseRendererConfig,
@@ -83,14 +84,18 @@ from renderers.configs import (
 )
 from renderers.custom import custom_renderer_config, load_custom_renderer, load_target
 
-# Concrete renderer classes are lazy-loaded so that consumers needing only the
-# config layer (``RendererConfig`` discriminated union) don't import every
-# renderer module. Renderer tokenizer annotations use the local ``Tokenizer``
-# protocols, so resolving a text renderer remains safe when the optional
+if TYPE_CHECKING:
+    from renderers.client import MalformedGenerateResponseError, OverlongPromptError
+
+# Concrete renderer classes and the HTTP client's errors are lazy-loaded so that
+# consumers needing only the config layer (``RendererConfig`` discriminated union)
+# import neither every renderer module nor the OpenAI client. Renderer tokenizer
+# annotations use the local ``Tokenizer`` protocols, so resolving a text renderer
+# remains safe when the optional
 # ``transformers`` dependency is absent. ``__getattr__`` (PEP 562) resolves the
 # names on first attribute access, while ``renderers.base._populate_registry``
 # handles lazy registration for ``create_renderer``.
-_LAZY_RENDERERS: dict[str, str] = {
+_LAZY_EXPORTS: dict[str, str] = {
     "DeepSeekR1Renderer": "renderers.deepseek_r1",
     "DeepSeekV3Renderer": "renderers.deepseek_v3",
     "DeepSeekV4Renderer": "renderers.deepseek_v4",
@@ -111,11 +116,13 @@ _LAZY_RENDERERS: dict[str, str] = {
     "LagunaXS21Renderer": "renderers.laguna_xs2",
     "LagunaXS2Renderer": "renderers.laguna_xs2",
     "Llama3Renderer": "renderers.llama_3",
+    "MalformedGenerateResponseError": "renderers.client",
     "MiniMaxM2Renderer": "renderers.minimax_m2",
     "MuseGlimmerRenderer": "renderers.muse_glimmer",
     "Nemotron35Renderer": "renderers.nemotron3",
     "Nemotron3Renderer": "renderers.nemotron3",
     "Nemotron3UltraRenderer": "renderers.nemotron3",
+    "OverlongPromptError": "renderers.client",
     "PrimeQwen3Renderer": "renderers.prime_qwen3",
     "Qwen35Renderer": "renderers.qwen35",
     "Qwen36Renderer": "renderers.qwen36",
@@ -126,10 +133,10 @@ _LAZY_RENDERERS: dict[str, str] = {
 
 
 def __getattr__(name: str):
-    if name in _LAZY_RENDERERS:
+    if name in _LAZY_EXPORTS:
         import importlib
 
-        module = importlib.import_module(_LAZY_RENDERERS[name])
+        module = importlib.import_module(_LAZY_EXPORTS[name])
         value = getattr(module, name)
         globals()[name] = value  # cache for subsequent lookups
         return value
@@ -137,7 +144,7 @@ def __getattr__(name: str):
 
 
 def __dir__() -> list[str]:
-    return sorted(set(globals().keys()) | set(_LAZY_RENDERERS))
+    return sorted(set(globals().keys()) | set(_LAZY_EXPORTS))
 
 
 __all__ = [

{renderers-0.1.13.dev15 → renderers-0.1.13.dev17}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.13.dev15'
-__version_tuple__ = version_tuple = (0, 1, 13, 'dev15')
+__version__ = version = '0.1.13.dev17'
+__version_tuple__ = version_tuple = (0, 1, 13, 'dev17')
 
 __commit_id__ = commit_id = None

{renderers-0.1.13.dev15 → renderers-0.1.13.dev17}/renderers/client.py

@@ -157,7 +157,7 @@ def parse_generate_response(raw: bytes) -> dict[str, Any]:
 
 def _parse_packed_completion_logprobs(
     packed: Mapping[str, Any], completion_ids: list[int]
-) -> list[float]:
+) -> np.ndarray:
     """prime-rl's packed form: base64 float32 ``{data, shape, dtype}``, one per token."""
     values = np.frombuffer(base64.b64decode(packed["data"]), dtype=packed["dtype"])
     valid = np.isfinite(values) & (values > VLLM_LOGPROB_SENTINEL)
@@ -166,12 +166,12 @@ def _parse_packed_completion_logprobs(
             f"Engine response choice.completion_logprobs: {len(values)} values for "
             f"{len(completion_ids)} completion tokens, or a non-finite or missing (-9999) logprob."
         )
-    return values.astype(np.float64).tolist()
+    return values.astype(np.float32, copy=False)
 
 
 def _parse_compact_logprobs(
     choice: Mapping[str, Any], completion_ids: list[int], k: int | None
-) -> tuple[list[float], list[list[int]] | None, list[list[float]] | None]:
+) -> tuple[np.ndarray, list[list[int]] | None, list[list[float]] | None]:
     packed = choice.get("compact_logprobs")
     if not isinstance(packed, Mapping) or packed.get("format") != "u32-f32-le-v1":
         raise MalformedGenerateResponseError("Unsupported compact logprob format")
@@ -227,7 +227,7 @@ def _parse_compact_logprobs(
             top_ids.append(selected_ids)
             top_logprobs.append(selected_logprobs)
     return (
-        sampled,
+        np.asarray(sampled, dtype=np.float32),
         top_ids if k is not None else None,
         top_logprobs if k is not None else None,
     )
@@ -245,7 +245,7 @@ def _logprob_token_id(entry: Mapping[str, Any]) -> int | None:
 
 def _parse_completion_logprobs(
     choice: Mapping[str, Any], completion_ids: list[int]
-) -> list[float]:
+) -> np.ndarray:
     packed = choice.get("completion_logprobs")
     if packed is not None:
         return _parse_packed_completion_logprobs(packed, completion_ids)
@@ -297,7 +297,7 @@ def _parse_completion_logprobs(
                 f"Engine response choice.logprobs.content[{index}].logprob does not contain sampling evidence."
             )
         completion_logprobs.append(logprob)
-    return completion_logprobs
+    return np.asarray(completion_logprobs, dtype=np.float32)
 
 
 def _parse_sampling_mask(
@@ -501,6 +501,9 @@ async def generate(
     mm_placeholders, completion_ids, completion_logprobs, content,
     reasoning_content, tool_calls, finish_reason, routed_experts,
     weight_versions, multi_modal_data, prompt_attribution.
+    ``completion_logprobs`` is a float32 numpy array, one value per completion
+    token: vLLM samples in float32, so the packed form decodes without a copy
+    and the JSON forms narrow losslessly.
     ``renderer_prompt_ids`` is the unexpanded logical prompt when
     ``process_multimodal=False`` and ``None`` otherwise. ``weight_versions``
     is vLLM's (>= 0.32) list of ``{version, start, end}`` spans over

{renderers-0.1.13.dev15 → renderers-0.1.13.dev17}/tests/replay.py

@@ -44,5 +44,5 @@ def replay_client(completions, requests):
 
 def assert_evidence(result, ids):
     assert result["completion_ids"] == ids
-    assert result["completion_logprobs"] == [-0.25] * len(ids)
+    assert result["completion_logprobs"].tolist() == [-0.25] * len(ids)
     assert result["sampling_mask"] == [[tid] for tid in ids]

{renderers-0.1.13.dev15 → renderers-0.1.13.dev17}/tests/test_client.py

@@ -122,9 +122,14 @@ def test_parse_generate_response_preserves_multiple_compact_choices(separators):
         json.dumps({"choices": choices}, separators=separators).encode(),
     )
     for i, choice in zip((7, 8), payload["choices"]):
-        assert _parse_compact_logprobs(choice, [i], None) == ([-0.5], None, None)
+        sampled, top_ids, top_logprobs = _parse_compact_logprobs(choice, [i], None)
+        assert sampled.dtype == np.float32 and sampled.tolist() == [-0.5]
+        assert top_ids is None and top_logprobs is None
         assert base64.b64decode(choice["routed_experts"]["data"]) == bytes([i])
-    assert _parse_compact_logprobs(payload["choices"][2], [], 2) == ([], [], [])
+    sampled, top_ids, top_logprobs = _parse_compact_logprobs(
+        payload["choices"][2], [], 2
+    )
+    assert sampled.tolist() == [] and top_ids == [] and top_logprobs == []
 
 
 @pytest.mark.parametrize("sampled", [1, 3, 5])
@@ -594,7 +599,7 @@ def test_generate_preserves_zero_completion_logprob():
 
     result = _run_generate(client)
 
-    assert result["completion_logprobs"] == [0.0, -0.2]
+    assert result["completion_logprobs"] == pytest.approx([0.0, -0.2])
 
 
 def test_generate_reads_packed_completion_logprobs():
@@ -609,7 +614,8 @@ def test_generate_reads_packed_completion_logprobs():
 
     result = _run_generate(client)
 
-    assert result["completion_logprobs"] == values.tolist()
+    assert result["completion_logprobs"].dtype == np.float32
+    assert result["completion_logprobs"].tolist() == values.tolist()
 
     client.choice["completion_logprobs"]["data"] = base64.b64encode(
         np.array([-0.1, -9999.0], dtype=np.float32).tobytes()
@@ -1141,5 +1147,5 @@ def test_generate_forwards_reasoning_state_without_classifying_acceptance(
     assert result["reasoning_complete"] is reasoning_complete
     assert result["finish_reason"] == finish
     assert result["completion_ids"] == [7, 8]
-    assert result["completion_logprobs"] == [-0.1, -0.2]
+    assert result["completion_logprobs"] == pytest.approx([-0.1, -0.2])
     assert result["content"] == ""