Convert formatting to use ruff instead of yapf + isort (#26247)
Signed-off-by: Harry Mellor <19981378+hmellor@users.noreply.github.com>
This commit is contained in:
@@ -7,8 +7,7 @@ from typing import Optional, Union
|
||||
import regex as re
|
||||
from transformers import PreTrainedTokenizerBase
|
||||
|
||||
from vllm.entrypoints.openai.protocol import (ChatCompletionRequest,
|
||||
DeltaMessage)
|
||||
from vllm.entrypoints.openai.protocol import ChatCompletionRequest, DeltaMessage
|
||||
from vllm.logger import init_logger
|
||||
from vllm.reasoning import ReasoningParser, ReasoningParserManager
|
||||
|
||||
@@ -34,15 +33,14 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
self.response_start_expr = r"(?:Here's|Here is) my response:"
|
||||
|
||||
self.reasoning_regex = re.compile(
|
||||
rf"{self.think_start_expr}(.*?){self.response_start_expr}(.*)",
|
||||
re.DOTALL)
|
||||
rf"{self.think_start_expr}(.*?){self.response_start_expr}(.*)", re.DOTALL
|
||||
)
|
||||
|
||||
self.valid_think_starts = [
|
||||
"Here's my thought process:", "Here is my thought process:"
|
||||
]
|
||||
self.valid_response_starts = [
|
||||
"Here's my response:", "Here is my response:"
|
||||
"Here's my thought process:",
|
||||
"Here is my thought process:",
|
||||
]
|
||||
self.valid_response_starts = ["Here's my response:", "Here is my response:"]
|
||||
|
||||
# Substrings to match for sequence boundaries on raw text
|
||||
self.seq_boundary_end = ":"
|
||||
@@ -50,10 +48,11 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
|
||||
# The longest any thinking / start of response message can be
|
||||
self.longest_think_start = max(
|
||||
len(think_start) for think_start in self.valid_think_starts)
|
||||
len(think_start) for think_start in self.valid_think_starts
|
||||
)
|
||||
|
||||
def extract_reasoning_content(
|
||||
self, model_output: str, request: ChatCompletionRequest
|
||||
self, model_output: str, request: ChatCompletionRequest
|
||||
) -> tuple[Optional[str], Optional[str]]:
|
||||
"""Extract the reasoning content & content sections, respectively.
|
||||
If the sequence doesn't match what we expect, i.e., the model generates
|
||||
@@ -111,24 +110,27 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
DeltaMessage with either reasoning content or content, or None.
|
||||
"""
|
||||
reasoning_content, resp_seq_len, content = self._get_content_sections(
|
||||
current_text)
|
||||
current_text
|
||||
)
|
||||
# Either we haven't finished the start of the reasoning sequence,
|
||||
# or the model is generating something unexpected.
|
||||
if not reasoning_content:
|
||||
delta_message = self._get_delta_message_with_no_reasoning_bounds(
|
||||
current_text, delta_text)
|
||||
current_text, delta_text
|
||||
)
|
||||
# We have a start of reasoning message, but have not yet finished
|
||||
# the start of response sequence.
|
||||
elif not content:
|
||||
delta_message = self._get_delta_message_with_no_response_bounds(
|
||||
current_text, reasoning_content, delta_text)
|
||||
current_text, reasoning_content, delta_text
|
||||
)
|
||||
# We've finished both the start of reasoning and start of response seq.
|
||||
else:
|
||||
# This should never happen since we matched on the response
|
||||
assert resp_seq_len is not None
|
||||
delta_message = self._get_delta_message_with_both_bounds(
|
||||
delta_text, reasoning_content, content, current_text,
|
||||
resp_seq_len)
|
||||
delta_text, reasoning_content, content, current_text, resp_seq_len
|
||||
)
|
||||
if not delta_message.content and not delta_message.reasoning_content:
|
||||
return None
|
||||
return delta_message
|
||||
@@ -139,26 +141,27 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
|
||||
Args:
|
||||
text (str): Text to check for leading substr.
|
||||
|
||||
|
||||
Returns:
|
||||
bool: True if any of the possible reasoning start seqs match.
|
||||
"""
|
||||
return any(
|
||||
think_start.startswith(text)
|
||||
for think_start in self.valid_think_starts)
|
||||
think_start.startswith(text) for think_start in self.valid_think_starts
|
||||
)
|
||||
|
||||
def _is_response_start_substr(self, text: str) -> bool:
|
||||
"""Check if a text matches one of the possible start response seqs.
|
||||
|
||||
Args:
|
||||
text (str): Text to check for leading substr.
|
||||
|
||||
|
||||
Returns:
|
||||
bool: True if any of the possible response start seqs match.
|
||||
"""
|
||||
return any(
|
||||
response_start.startswith(text)
|
||||
for response_start in self.valid_response_starts)
|
||||
for response_start in self.valid_response_starts
|
||||
)
|
||||
|
||||
def _get_delta_message_with_no_reasoning_bounds(
|
||||
self,
|
||||
@@ -177,8 +180,7 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
"""
|
||||
prev_longest_length = len(current_text) - len(delta_text)
|
||||
is_substr = self._is_reasoning_start_substr(current_text)
|
||||
was_substr = self._is_reasoning_start_substr(
|
||||
current_text[:prev_longest_length])
|
||||
was_substr = self._is_reasoning_start_substr(current_text[:prev_longest_length])
|
||||
|
||||
# Check if we just generated something NOT in the special token seq;
|
||||
# if so, add everything that we previously skipped with this delta
|
||||
@@ -220,12 +222,13 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
# content and fully parse it out; we should not pass the : back.
|
||||
ends_with_start_response_seq = any(
|
||||
current_text.endswith(response_start)
|
||||
for response_start in self.valid_response_starts)
|
||||
for response_start in self.valid_response_starts
|
||||
)
|
||||
if reasoning_content is None or ends_with_start_response_seq:
|
||||
return DeltaMessage(reasoning_content=None, content=None)
|
||||
|
||||
# Consider previous / current text only within context of the reasoning
|
||||
previous_text = reasoning_content[:-len(delta_text)]
|
||||
previous_text = reasoning_content[: -len(delta_text)]
|
||||
current_text = reasoning_content
|
||||
|
||||
# We need to be careful about adding unfinished response sequences;
|
||||
@@ -234,12 +237,21 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
delta_idx = delta_text.rfind(self.seq_boundary_start)
|
||||
|
||||
# Check the state of potential start of response substring matches.
|
||||
prev_was_substr = self._is_response_start_substr(
|
||||
previous_text[prev_idx:]) if prev_idx >= 0 else False
|
||||
delta_continues_substr = self._is_response_start_substr(
|
||||
current_text[prev_idx:]) if prev_idx >= 0 else False
|
||||
delta_new_substr = self._is_response_start_substr(
|
||||
delta_text[delta_idx:]) if delta_idx >= 0 else False
|
||||
prev_was_substr = (
|
||||
self._is_response_start_substr(previous_text[prev_idx:])
|
||||
if prev_idx >= 0
|
||||
else False
|
||||
)
|
||||
delta_continues_substr = (
|
||||
self._is_response_start_substr(current_text[prev_idx:])
|
||||
if prev_idx >= 0
|
||||
else False
|
||||
)
|
||||
delta_new_substr = (
|
||||
self._is_response_start_substr(delta_text[delta_idx:])
|
||||
if delta_idx >= 0
|
||||
else False
|
||||
)
|
||||
|
||||
# Delta only contains potential continued response sequence text.
|
||||
if delta_continues_substr:
|
||||
@@ -248,18 +260,17 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
if not prev_was_substr:
|
||||
# Delta may be starting a new response seq but has other text too.
|
||||
if delta_new_substr:
|
||||
return DeltaMessage(reasoning_content=delta_text[:delta_idx],
|
||||
content=None)
|
||||
return DeltaMessage(
|
||||
reasoning_content=delta_text[:delta_idx], content=None
|
||||
)
|
||||
# Normal case for most reasoning text (no potential special seqs).
|
||||
return DeltaMessage(reasoning_content=delta_text, content=None)
|
||||
# The substring that previously seemed to be a potential response
|
||||
# seq wasn't one; we need to add the content to the delta message,
|
||||
# and also slice off the potential response sequence
|
||||
elif delta_new_substr:
|
||||
reasoning_content = previous_text[
|
||||
prev_idx:] + delta_text[:delta_idx]
|
||||
return DeltaMessage(reasoning_content=reasoning_content,
|
||||
content=None)
|
||||
reasoning_content = previous_text[prev_idx:] + delta_text[:delta_idx]
|
||||
return DeltaMessage(reasoning_content=reasoning_content, content=None)
|
||||
# No new substring yet, and we broke our old one; take the whole delta
|
||||
return DeltaMessage(
|
||||
reasoning_content=previous_text[prev_idx:] + delta_text,
|
||||
@@ -288,23 +299,21 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
DeltaMessage: Message containing the parsed content.
|
||||
"""
|
||||
# Always have content; take length to the end
|
||||
delta_content = delta_text[-len(response_content):]
|
||||
reasoning_end_idx = len(delta_text) - (len(response_content) +
|
||||
response_seq_len)
|
||||
delta_content = delta_text[-len(response_content) :]
|
||||
reasoning_end_idx = len(delta_text) - (len(response_content) + response_seq_len)
|
||||
|
||||
if reasoning_end_idx < 0:
|
||||
delta_reasoning_content = None
|
||||
else:
|
||||
# Get the starting offset
|
||||
start_reasoning_content_idx = len(
|
||||
reasoning_content) + response_seq_len + len(
|
||||
response_content) - 1
|
||||
start_reasoning_content_idx = (
|
||||
len(reasoning_content) + response_seq_len + len(response_content) - 1
|
||||
)
|
||||
delta_offset = len(current_text) - len(delta_text)
|
||||
start_offset = start_reasoning_content_idx - delta_offset
|
||||
if start_offset < 0:
|
||||
start_offset = 0
|
||||
delta_reasoning_content = delta_text[
|
||||
start_offset:reasoning_end_idx]
|
||||
delta_reasoning_content = delta_text[start_offset:reasoning_end_idx]
|
||||
|
||||
return DeltaMessage(
|
||||
reasoning_content=delta_reasoning_content,
|
||||
@@ -329,7 +338,8 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
start_reasoning_content = None
|
||||
parsed_content = False
|
||||
delimiter_idxs = [
|
||||
idx for idx, char in enumerate(current_text)
|
||||
idx
|
||||
for idx, char in enumerate(current_text)
|
||||
if char == self.seq_boundary_end
|
||||
]
|
||||
|
||||
@@ -346,17 +356,15 @@ class GraniteReasoningParser(ReasoningParser):
|
||||
# Check to see if the start of response seq if complete
|
||||
elif not parsed_content:
|
||||
for response_start in self.valid_response_starts:
|
||||
if current_chunk[-len(response_start) +
|
||||
1:] == response_start[:-1]:
|
||||
if current_chunk[-len(response_start) + 1 :] == response_start[:-1]:
|
||||
# Mark end of reasoning and start response content
|
||||
# after the start of response sequence.
|
||||
end_reasoning_content = current_chunk_end - len(
|
||||
response_start)
|
||||
end_reasoning_content = current_chunk_end - len(response_start)
|
||||
reasoning_content = current_text[
|
||||
start_reasoning_content:end_reasoning_content]
|
||||
response_content = current_text[current_chunk_end + 1:]
|
||||
return reasoning_content, len(
|
||||
response_start), response_content
|
||||
start_reasoning_content:end_reasoning_content
|
||||
]
|
||||
response_content = current_text[current_chunk_end + 1 :]
|
||||
return reasoning_content, len(response_start), response_content
|
||||
|
||||
if start_reasoning_content and not parsed_content:
|
||||
return current_text[start_reasoning_content:], None, None
|
||||
|
||||
Reference in New Issue
Block a user