Skip to content

vllm.inputs.parse

ParsedSingletonPrompt module-attribute 

ParsedSingletonPrompt = Union[
    ParsedStrPrompt,
    ParsedTextPrompt,
    ParsedTokensPrompt,
    ParsedEmbedsPrompt,
]

ParsedEmbedsPrompt

Bases: TypedDict

Source code in vllm/inputs/parse.py 
93
94
95
class ParsedEmbedsPrompt(TypedDict):
    type: Literal["embeds"]
    content: EmbedsPrompt

content instance-attribute 

content: EmbedsPrompt

type instance-attribute 

type: Literal['embeds']

ParsedStrPrompt

Bases: TypedDict

Source code in vllm/inputs/parse.py 
78
79
80
class ParsedStrPrompt(TypedDict):
    type: Literal["str"]
    content: str

content instance-attribute 

content: str

type instance-attribute 

type: Literal['str']

ParsedText

Bases: TypedDict

Source code in vllm/inputs/parse.py 
19
20
21
class ParsedText(TypedDict):
    content: str
    is_tokens: Literal[False]

content instance-attribute 

content: str

is_tokens instance-attribute 

is_tokens: Literal[False]

ParsedTextPrompt

Bases: TypedDict

Source code in vllm/inputs/parse.py 
83
84
85
class ParsedTextPrompt(TypedDict):
    type: Literal["text"]
    content: TextPrompt

content instance-attribute 

content: TextPrompt

type instance-attribute 

type: Literal['text']

ParsedTokens

Bases: TypedDict

Source code in vllm/inputs/parse.py 
24
25
26
class ParsedTokens(TypedDict):
    content: list[int]
    is_tokens: Literal[True]

content instance-attribute 

content: list[int]

is_tokens instance-attribute 

is_tokens: Literal[True]

ParsedTokensPrompt

Bases: TypedDict

Source code in vllm/inputs/parse.py 
88
89
90
class ParsedTokensPrompt(TypedDict):
    type: Literal["tokens"]
    content: TokensPrompt

content instance-attribute 

content: TokensPrompt

type instance-attribute 

type: Literal['tokens']

PromptComponents

Bases: NamedTuple

Source code in vllm/inputs/parse.py 
158
159
160
161
class PromptComponents(NamedTuple):
    text: Optional[str] = None
    token_ids: Optional[list[int]] = None
    embeds: Optional["torch.Tensor"] = None

embeds class-attribute instance-attribute 

embeds: Optional[Tensor] = None

text class-attribute instance-attribute 

text: Optional[str] = None

token_ids class-attribute instance-attribute 

token_ids: Optional[list[int]] = None

get_prompt_components 

get_prompt_components(
    prompt: PromptType,
) -> PromptComponents
Source code in vllm/inputs/parse.py 
164
165
166
167
168
169
170
171
172
173
174
175
def get_prompt_components(prompt: PromptType) -> PromptComponents:
    if isinstance(prompt, str):
        return PromptComponents(text=prompt)

    if (encoder_prompt := prompt.get("encoder_prompt")):
        return get_prompt_components(encoder_prompt)  # type: ignore[arg-type]

    return PromptComponents(
        text=prompt.get("prompt"),  # type: ignore[arg-type]
        token_ids=prompt.get("prompt_token_ids"),  # type: ignore[arg-type]
        embeds=prompt.get("prompt_embeds"),
    )

is_explicit_encoder_decoder_prompt 

is_explicit_encoder_decoder_prompt(
    prompt: PromptType,
) -> TypeIs[ExplicitEncoderDecoderPrompt]
Source code in vllm/inputs/parse.py 
140
141
142
def is_explicit_encoder_decoder_prompt(
    prompt: PromptType, ) -> TypeIs[ExplicitEncoderDecoderPrompt]:
    return isinstance(prompt, dict) and "encoder_prompt" in prompt

parse_and_batch_prompt 

parse_and_batch_prompt(
    prompt: Union[str, list[str]],
) -> Sequence[ParsedText]

parse_and_batch_prompt(
    prompt: Union[list[int], list[list[int]]],
) -> Sequence[ParsedTokens]

parse_and_batch_prompt(
    prompt: Union[
        str, list[str], list[int], list[list[int]]
    ],
) -> Union[Sequence[ParsedText], Sequence[ParsedTokens]]
Source code in vllm/inputs/parse.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
def parse_and_batch_prompt(
    prompt: Union[str, list[str], list[int], list[list[int]]],
) -> Union[Sequence[ParsedText], Sequence[ParsedTokens]]:
    if isinstance(prompt, str):
        # case 1: a string
        return [ParsedText(content=prompt, is_tokens=False)]

    if isinstance(prompt, list):
        if len(prompt) == 0:
            raise ValueError("please provide at least one prompt")

        if is_list_of(prompt, str):
            # case 2: array of strings
            prompt = cast(list[str], prompt)
            return [
                ParsedText(content=elem, is_tokens=False) for elem in prompt
            ]
        if is_list_of(prompt, int):
            # case 3: array of tokens
            prompt = cast(list[int], prompt)
            return [ParsedTokens(content=prompt, is_tokens=True)]
        if is_list_of(prompt, list):
            prompt = cast(list[list[int]], prompt)
            if len(prompt[0]) == 0:
                raise ValueError("please provide at least one prompt")

            if is_list_of(prompt[0], int):
                # case 4: array of token arrays
                return [
                    ParsedTokens(content=elem, is_tokens=True)
                    for elem in prompt
                ]

    raise TypeError("prompt must be a string, array of strings, "
                    "array of tokens, or array of token arrays")

parse_singleton_prompt 

parse_singleton_prompt(prompt: str) -> ParsedStrPrompt

parse_singleton_prompt(
    prompt: TextPrompt,
) -> ParsedTextPrompt

parse_singleton_prompt(
    prompt: TokensPrompt,
) -> ParsedTokensPrompt

parse_singleton_prompt(
    prompt: EmbedsPrompt,
) -> ParsedEmbedsPrompt

parse_singleton_prompt(
    prompt: SingletonPrompt,
) -> ParsedSingletonPrompt
Source code in vllm/inputs/parse.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def parse_singleton_prompt(prompt: SingletonPrompt) -> ParsedSingletonPrompt:
    if isinstance(prompt, str):
        return ParsedStrPrompt(type="str", content=prompt)
    elif isinstance(prompt, dict):
        # Type ignores are because mypy does not correctly infer the TypedDicts
        # Pyright does succeed.
        if "prompt_embeds" in prompt:
            return ParsedEmbedsPrompt(
                type="embeds", content=prompt)  # type: ignore[typeddict-item]
        elif "prompt_token_ids" in prompt:
            return ParsedTokensPrompt(
                type="tokens", content=prompt)  # type: ignore[typeddict-item]
        elif "prompt" in prompt:
            return ParsedTextPrompt(type="text", content=prompt)
    raise TypeError(
        "inputs must be a string, TextPrompt, TokensPrompt, or EmbedsPrompt")

split_enc_dec_inputs 

split_enc_dec_inputs(
    inputs: ProcessorInputs,
) -> tuple[Optional[SingletonInputs], SingletonInputs]
Source code in vllm/inputs/parse.py 
145
146
147
148
149
150
151
152
153
154
155
def split_enc_dec_inputs(
    inputs: ProcessorInputs,
) -> tuple[Optional[SingletonInputs], SingletonInputs]:
    if "encoder" in inputs and "decoder" in inputs:
        # NOTE: This passes pyright but not mypy
        return (
            inputs["encoder"],  # type: ignore[typeddict-item]
            inputs["decoder"],  # type: ignore[typeddict-item]
        )

    return None, inputs