Skip to content

vllm.renderers

Modules:

Name Description
deepseek_v32
grok2
hf
mistral
protocol
registry
terratorch

__all__ module-attribute 

__all__ = [
    "RendererLike",
    "RendererRegistry",
    "renderer_from_config",
]

RendererLike

Bases: Protocol

Source code in vllm/renderers/protocol.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class RendererLike(Protocol):
    @classmethod
    def from_config(
        cls,
        config: "ModelConfig",
        tokenizer_kwargs: dict[str, Any],
    ) -> "RendererLike":
        raise NotImplementedError

    @property
    def tokenizer(self) -> TokenizerLike | None:
        raise NotImplementedError

    def get_tokenizer(self) -> TokenizerLike:
        tokenizer = self.tokenizer
        if tokenizer is None:
            raise ValueError("Tokenizer not available when `skip_tokenizer_init=True`")

        return tokenizer

    def render_messages(
        self,
        messages: list["ChatCompletionMessageParam"],
        **kwargs,
    ) -> tuple[list["ConversationMessage"], TextPrompt | TokensPrompt]:
        raise NotImplementedError

    async def render_messages_async(
        self,
        messages: list["ChatCompletionMessageParam"],
        **kwargs,
    ) -> tuple[list["ConversationMessage"], TextPrompt | TokensPrompt]:
        return self.render_messages(messages, **kwargs)

tokenizer property 

tokenizer: TokenizerLike | None

from_config classmethod 

from_config(
    config: ModelConfig, tokenizer_kwargs: dict[str, Any]
) -> RendererLike
Source code in vllm/renderers/protocol.py 
17
18
19
20
21
22
23
@classmethod
def from_config(
    cls,
    config: "ModelConfig",
    tokenizer_kwargs: dict[str, Any],
) -> "RendererLike":
    raise NotImplementedError

get_tokenizer 

get_tokenizer() -> TokenizerLike
Source code in vllm/renderers/protocol.py 
29
30
31
32
33
34
def get_tokenizer(self) -> TokenizerLike:
    tokenizer = self.tokenizer
    if tokenizer is None:
        raise ValueError("Tokenizer not available when `skip_tokenizer_init=True`")

    return tokenizer

render_messages 

render_messages(
    messages: list[ChatCompletionMessageParam], **kwargs
) -> tuple[
    list[ConversationMessage], TextPrompt | TokensPrompt
]
Source code in vllm/renderers/protocol.py 
36
37
38
39
40
41
def render_messages(
    self,
    messages: list["ChatCompletionMessageParam"],
    **kwargs,
) -> tuple[list["ConversationMessage"], TextPrompt | TokensPrompt]:
    raise NotImplementedError

render_messages_async async 

render_messages_async(
    messages: list[ChatCompletionMessageParam], **kwargs
) -> tuple[
    list[ConversationMessage], TextPrompt | TokensPrompt
]
Source code in vllm/renderers/protocol.py 
43
44
45
46
47
48
async def render_messages_async(
    self,
    messages: list["ChatCompletionMessageParam"],
    **kwargs,
) -> tuple[list["ConversationMessage"], TextPrompt | TokensPrompt]:
    return self.render_messages(messages, **kwargs)

RendererRegistry dataclass

Source code in vllm/renderers/registry.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@dataclass
class RendererRegistry:
    # Renderer mode ->  (renderer module, renderer class)
    renderers: dict[str, tuple[str, str]] = field(default_factory=dict)

    def register(self, renderer_mode: str, module: str, class_name: str) -> None:
        if renderer_mode in self.renderers:
            logger.warning(
                "%s.%s is already registered for renderer_mode=%r. "
                "It is overwritten by the new one.",
                module,
                class_name,
                renderer_mode,
            )

        self.renderers[renderer_mode] = (module, class_name)

        return None

    def load_renderer_cls(self, renderer_mode: str) -> type[RendererLike]:
        if renderer_mode not in self.renderers:
            raise ValueError(f"No renderer registered for {renderer_mode=!r}.")

        module, class_name = self.renderers[renderer_mode]
        logger.debug_once(f"Loading {class_name} for {renderer_mode=!r}")

        return resolve_obj_by_qualname(f"{module}.{class_name}")

    def load_renderer(
        self,
        renderer_mode: str,
        config: "ModelConfig",
        tokenizer_kwargs: dict[str, Any],
    ) -> RendererLike:
        renderer_cls = self.load_renderer_cls(renderer_mode)
        return renderer_cls.from_config(config, tokenizer_kwargs)

renderers class-attribute instance-attribute 

renderers: dict[str, tuple[str, str]] = field(
    default_factory=dict
)

__init__ 

__init__(
    renderers: dict[str, tuple[str, str]] = dict(),
) -> None

load_renderer 

load_renderer(
    renderer_mode: str,
    config: ModelConfig,
    tokenizer_kwargs: dict[str, Any],
) -> RendererLike
Source code in vllm/renderers/registry.py 
55
56
57
58
59
60
61
62
def load_renderer(
    self,
    renderer_mode: str,
    config: "ModelConfig",
    tokenizer_kwargs: dict[str, Any],
) -> RendererLike:
    renderer_cls = self.load_renderer_cls(renderer_mode)
    return renderer_cls.from_config(config, tokenizer_kwargs)

load_renderer_cls 

load_renderer_cls(renderer_mode: str) -> type[RendererLike]
Source code in vllm/renderers/registry.py 
46
47
48
49
50
51
52
53
def load_renderer_cls(self, renderer_mode: str) -> type[RendererLike]:
    if renderer_mode not in self.renderers:
        raise ValueError(f"No renderer registered for {renderer_mode=!r}.")

    module, class_name = self.renderers[renderer_mode]
    logger.debug_once(f"Loading {class_name} for {renderer_mode=!r}")

    return resolve_obj_by_qualname(f"{module}.{class_name}")

register 

register(
    renderer_mode: str, module: str, class_name: str
) -> None
Source code in vllm/renderers/registry.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
def register(self, renderer_mode: str, module: str, class_name: str) -> None:
    if renderer_mode in self.renderers:
        logger.warning(
            "%s.%s is already registered for renderer_mode=%r. "
            "It is overwritten by the new one.",
            module,
            class_name,
            renderer_mode,
        )

    self.renderers[renderer_mode] = (module, class_name)

    return None

renderer_from_config 

renderer_from_config(config: ModelConfig, **kwargs)
Source code in vllm/renderers/registry.py 
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
def renderer_from_config(config: "ModelConfig", **kwargs):
    tokenizer_mode, tokenizer_name, args, kwargs = tokenizer_args_from_config(
        config, **kwargs
    )

    if config.tokenizer_mode == "auto" and config.model_impl == "terratorch":
        renderer_mode = "terratorch"
    else:
        renderer_mode = tokenizer_mode

    return RENDERER_REGISTRY.load_renderer(
        renderer_mode,
        config,
        tokenizer_kwargs={**kwargs, "tokenizer_name": tokenizer_name},
    )