Skip to content

vllm.v1.structured_output.request

StructuredOutputRequest dataclass

Source code in vllm/v1/structured_output/request.py 
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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@dataclasses.dataclass
class StructuredOutputRequest:
    params: StructuredOutputsParams
    _grammar: Future[StructuredOutputGrammar] | StructuredOutputGrammar | None = None
    reasoning_ended: bool | None = None

    @staticmethod
    def from_sampling_params(
        sampling_params: SamplingParams | None,
    ) -> "StructuredOutputRequest | None":
        if sampling_params is None:
            return None
        params = sampling_params.structured_outputs
        return StructuredOutputRequest(params=params) if params else None

    def _check_grammar_completion(self) -> bool:
        # NOTE: We have to lazy import to gate circular imports
        from vllm.v1.request import RequestStatus

        if isinstance(self._grammar, Future):
            try:
                # We will check whether the future is ready within 100 us
                self._grammar = self._grammar.result(timeout=0.0001)
                self.status = RequestStatus.WAITING
            except TimeoutError:
                return False
        return True

    @property
    def is_grammar_ready(self) -> bool:
        return self._check_grammar_completion()

    @property
    def grammar(self) -> StructuredOutputGrammar | None:
        completed = self._check_grammar_completion()
        return (
            cast(StructuredOutputGrammar | None, self._grammar) if completed else None
        )

    @grammar.setter
    def grammar(
        self, grammar: StructuredOutputGrammar | Future[StructuredOutputGrammar]
    ) -> None:
        self._grammar = grammar

    @functools.cached_property
    def structured_output_key(self) -> StructuredOutputKey:
        return get_structured_output_key(self.params)

_grammar class-attribute instance-attribute 

_grammar: (
    Future[StructuredOutputGrammar]
    | StructuredOutputGrammar
    | None
) = None

grammar property writable 

grammar: StructuredOutputGrammar | None

is_grammar_ready property 

is_grammar_ready: bool

params instance-attribute 

params: StructuredOutputsParams

reasoning_ended class-attribute instance-attribute 

reasoning_ended: bool | None = None

structured_output_key cached property 

structured_output_key: StructuredOutputKey

__init__ 

__init__(
    params: StructuredOutputsParams,
    _grammar: Future[StructuredOutputGrammar]
    | StructuredOutputGrammar
    | None = None,
    reasoning_ended: bool | None = None,
) -> None

_check_grammar_completion 

_check_grammar_completion() -> bool
Source code in vllm/v1/structured_output/request.py 
33
34
35
36
37
38
39
40
41
42
43
44
def _check_grammar_completion(self) -> bool:
    # NOTE: We have to lazy import to gate circular imports
    from vllm.v1.request import RequestStatus

    if isinstance(self._grammar, Future):
        try:
            # We will check whether the future is ready within 100 us
            self._grammar = self._grammar.result(timeout=0.0001)
            self.status = RequestStatus.WAITING
        except TimeoutError:
            return False
    return True

from_sampling_params staticmethod 

from_sampling_params(
    sampling_params: SamplingParams | None,
) -> StructuredOutputRequest | None
Source code in vllm/v1/structured_output/request.py 
24
25
26
27
28
29
30
31
@staticmethod
def from_sampling_params(
    sampling_params: SamplingParams | None,
) -> "StructuredOutputRequest | None":
    if sampling_params is None:
        return None
    params = sampling_params.structured_outputs
    return StructuredOutputRequest(params=params) if params else None

get_structured_output_key 

get_structured_output_key(
    params: StructuredOutputsParams,
) -> StructuredOutputKey
Source code in vllm/v1/structured_output/request.py 
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
def get_structured_output_key(params: StructuredOutputsParams) -> StructuredOutputKey:
    if params.json is not None:
        if not isinstance(params.json, str):
            json_str = json.dumps(params.json)
        else:
            json_str = params.json
        return StructuredOutputOptions.JSON, json_str
    if params.json_object:
        return StructuredOutputOptions.JSON_OBJECT, ""
    if params.regex is not None:
        return StructuredOutputOptions.REGEX, params.regex
    if params.choice is not None:
        if not isinstance(params.choice, str):
            json_str = json.dumps(params.choice)
        else:
            json_str = params.choice
        return StructuredOutputOptions.CHOICE, json_str
    if params.grammar is not None:
        return StructuredOutputOptions.GRAMMAR, params.grammar
    if params.structural_tag is not None:
        return StructuredOutputOptions.STRUCTURAL_TAG, params.structural_tag
    raise ValueError("No valid structured output parameter found")