update flake8 version to support pre-commit in python3.12

.flake8

@@ -1,5 +1,5 @@
 [flake8]
-ignore = E203, E402, E501, E731, E741, W503, W605, E722
+ignore = E203, E402, E501, E731, E741, W503, W605, E722, E231, W604, E702, E226, E221, E713, E271
 max-line-length = 119
 
 # E402: module level import not at top of file

.pre-commit-config.yaml

@@ -7,7 +7,7 @@ default_stages:
 #   - manual # Run in CI
 repos:
 -   repo: https://github.com/psf/black.git
-    rev: 22.8.0
+    rev: 25.1.0
     hooks:
     -   id: black
         files: \.(py|pyi)$
@@ -18,7 +18,7 @@ repos:
     hooks:
     -   id: isort
 -   repo: https://github.com/PyCQA/flake8
-    rev: 4.0.1
+    rev: 7.0.0
     hooks:
     -   id: flake8
 # 代码检查

custom_ops/xpu_ops/test/python/ops/test_get_padding_offset.py

@@ -29,7 +29,13 @@
     ids_len = seq_lens[i, 0]
     input_ids[i, 0:ids_len] = np.random.randint(1, 10, seq_lens[i, 0], "int64")
 
-(x_remove_padding, cum_offsets_out, padding_offset, cu_seqlens_q, cu_seqlens_k,) = get_padding_offset(
+(
+    x_remove_padding,
+    cum_offsets_out,
+    padding_offset,
+    cu_seqlens_q,
+    cu_seqlens_k,
+) = get_padding_offset(
     paddle.to_tensor(input_ids),
     paddle.to_tensor(cum_offset),
     paddle.to_tensor(token_num),

fastdeploy/cache_manager/prefix_cache_manager.py

@@ -473,7 +473,10 @@ def request_block_ids(self, task, block_size, dec_token_num, *args):
                 current_time = time.time()
                 self._update_matched_node_info(req_id, match_block_node, current_time)
                 # 2. prepare cache
-                (gpu_recv_block_ids, gpu_extra_block_ids,) = self._prepare_cache(
+                (
+                    gpu_recv_block_ids,
+                    gpu_extra_block_ids,
+                ) = self._prepare_cache(
                     req_id,
                     input_ids,
                     block_size,

fastdeploy/distributed/custom_all_reduce/cuda_wrapper.py

@@ -113,10 +113,7 @@ class CudaRTLibrary:
         Function(
             "cudaStreamIsCapturing",
             cudaError_t,
-            [
-                cudaStream_t,
-                ctypes.POINTER(cudaStreamCaptureStatus)
-            ]
+            [cudaStream_t, ctypes.POINTER(cudaStreamCaptureStatus)],
         ),
     ]
 
@@ -197,9 +194,8 @@ def cudaIpcOpenMemHandle(self, handle: cudaIpcMemHandle_t) -> ctypes.c_void_p:
             self.funcs["cudaIpcOpenMemHandle"](ctypes.byref(devPtr), handle, cudaIpcMemLazyEnablePeerAccess)
         )
         return devPtr
+
     def cudaStreamIsCapturing(self, stream: cudaStream_t) -> ctypes.c_int:
         is_capturing = ctypes.c_int()
-        self.CUDART_CHECK(
-            self.funcs["cudaStreamIsCapturing"](stream, is_capturing)
-        )
+        self.CUDART_CHECK(self.funcs["cudaStreamIsCapturing"](stream, is_capturing))
         return is_capturing

fastdeploy/engine/args_utils.py

@@ -559,8 +559,8 @@ def add_cli_args(parser: FlexibleArgumentParser) -> FlexibleArgumentParser:
             "--ips",
             type=lambda s: s.split(",") if s else None,
             default=EngineArgs.ips,
-            help=
-            "IP addresses of all nodes participating in distributed inference.")
+            help="IP addresses of all nodes participating in distributed inference.",
+        )
 
         # Performance tuning parameters group
         perf_group = parser.add_argument_group("Performance Tuning")

fastdeploy/entrypoints/engine_client.py

@@ -41,7 +41,7 @@ def __init__(
         mm_processor_kwargs,
         enable_mm=False,
         reasoning_parser=None,
-        data_parallel_size=1
+        data_parallel_size=1,
     ):
         input_processor = InputPreprocessor(
             tokenizer,
@@ -55,8 +55,7 @@ def __init__(
         self.data_processor = input_processor.create_processor()
         self.max_model_len = max_model_len
         max_chips_per_node = 16 if current_platform.is_iluvatar() else 8
-        array_size = min(
-            max_chips_per_node, tensor_parallel_size * data_parallel_size)
+        array_size = min(max_chips_per_node, tensor_parallel_size * data_parallel_size)
         self.worker_healthy_live_recorded_time_array = np.zeros(shape=[array_size], dtype=np.int32)
         self.worker_healthy_live_signal = IPCSignal(
             name="worker_healthy_live_signal",

fastdeploy/entrypoints/openai/api_server.py

@@ -113,7 +113,7 @@ async def lifespan(app: FastAPI):
         args.mm_processor_kwargs,
         args.enable_mm,
         args.reasoning_parser,
-        args.data_parallel_size
+        args.data_parallel_size,
     )
     app.state.dynamic_load_weight = args.dynamic_load_weight
     chat_handler = OpenAIServingChat(engine_client, pid, args.ips)

fastdeploy/entrypoints/openai/protocol.py

@@ -478,7 +478,7 @@ class ChatCompletionRequest(BaseModel):
     top_p: Optional[float] = None
     top_k: Optional[int] = None
     min_p: Optional[float] = None
-    user: Optional[str] = None  
+    user: Optional[str] = None
     metadata: Optional[dict] = None
     extra_body: Optional[dict] = None
     return_token_ids: Optional[bool] = False

fastdeploy/entrypoints/openai/serving_chat.py

@@ -19,9 +19,10 @@
 import traceback
 import uuid
 from typing import List, Optional
-import numpy as np
+
 import aiozmq
 import msgpack
+import numpy as np
 from aiozmq import zmq
 
 from fastdeploy.entrypoints.openai.protocol import (
@@ -151,7 +152,9 @@ async def chat_completion_stream_generator(
             if request.metadata is not None:
                 enable_thinking = request.metadata.get("enable_thinking")
                 include_stop_str_in_output = request.metadata.get("include_stop_str_in_output", False)
-            enable_return_token_ids = request.return_token_ids or (request.extra_body is not None and request.extra_body.get('return_token_ids', False))
+            enable_return_token_ids = request.return_token_ids or (
+                request.extra_body is not None and request.extra_body.get("return_token_ids", False)
+            )
             while num_choices > 0:
                 try:
                     raw_data = await asyncio.wait_for(dealer.read(), timeout=10)
@@ -193,13 +196,13 @@ async def chat_completion_stream_generator(
                             choice = ChatCompletionResponseStreamChoice(
                                 index=i,
                                 delta=DeltaMessage(
-                                    role="assistant", 
-                                    content="", 
-                                    reasoning_content="", 
+                                    role="assistant",
+                                    content="",
+                                    reasoning_content="",
                                     tool_calls=None,
                                     prompt_token_ids=None,
                                     completion_token_ids=None,
-                                )
+                                ),
                             )
                             if enable_return_token_ids:
                                 choice.delta.prompt_token_ids = list(prompt_token_ids)
@@ -238,10 +241,10 @@ async def chat_completion_stream_generator(
 
                     previous_num_tokens += len(output["token_ids"])
                     delta_message = DeltaMessage(
-                        content=delta_text, 
-                        reasoning_content=output.get("reasoning_content"), \
+                        content=delta_text,
+                        reasoning_content=output.get("reasoning_content"),
                         prompt_token_ids=None,
-                        completion_token_ids=None, 
+                        completion_token_ids=None,
                         tool_calls=output.get("tool_call_content", []),
                     )
 
@@ -329,7 +332,9 @@ async def chat_completion_full_generator(
         final_res = None
         enable_thinking = None
         include_stop_str_in_output = False
-        enable_return_token_ids = request.return_token_ids or (request.extra_body is not None and request.extra_body.get('return_token_ids', False))
+        enable_return_token_ids = request.return_token_ids or (
+            request.extra_body is not None and request.extra_body.get("return_token_ids", False)
+        )
         try:
             dealer = await aiozmq.create_zmq_stream(zmq.DEALER, connect=f"ipc:///dev/shm/router_{self.pid}.ipc")
             dealer.write([b"", request_id.encode("utf-8")])
@@ -403,7 +408,7 @@ async def chat_completion_full_generator(
             reasoning_content=output.get("reasoning_content"),
             tool_calls=output.get("tool_call_content"),
             prompt_token_ids=prompt_token_ids if enable_return_token_ids else None,
-            completion_token_ids=completion_token_ids if enable_return_token_ids else None,
+            completion_token_ids=(completion_token_ids if enable_return_token_ids else None),
         )
         logprobs_full_res = None
         if logprob_contents:

fastdeploy/entrypoints/openai/serving_completion.py

@@ -18,9 +18,10 @@
 import time
 import uuid
 from typing import List
-import numpy as np
+
 import aiozmq
 import msgpack
+import numpy as np
 from aiozmq import zmq
 
 from fastdeploy.engine.request import RequestOutput
@@ -48,7 +49,6 @@ def __init__(self, engine_client, pid, ips):
             else:
                 self.master_ip = self.master_ip.split(",")[0]
 
-
     def _check_master(self):
         if self.master_ip is None:
             return True
@@ -238,7 +238,9 @@ async def completion_stream_generator(
                 model=model_name,
                 choices=choices,
             )
-            enable_return_token_ids = request.return_token_ids or (request.extra_body is not None and request.extra_body.get('return_token_ids', False))
+            enable_return_token_ids = request.return_token_ids or (
+                request.extra_body is not None and request.extra_body.get("return_token_ids", False)
+            )
             current_waiting_time = 0
             while num_choices > 0:
                 try:
@@ -267,12 +269,16 @@ async def completion_stream_generator(
                                 id=request_id,
                                 created=created_time,
                                 model=model_name,
-                                choices=[CompletionResponseStreamChoice(
-                                    index=idx,
-                                    text="",
-                                    prompt_token_ids=list(prompt_batched_token_ids[idx]) if enable_return_token_ids else None,
-                                    completion_token_ids=None,
-                                )]
+                                choices=[
+                                    CompletionResponseStreamChoice(
+                                        index=idx,
+                                        text="",
+                                        prompt_token_ids=(
+                                            list(prompt_batched_token_ids[idx]) if enable_return_token_ids else None
+                                        ),
+                                        completion_token_ids=None,
+                                    )
+                                ],
                             )
                             yield f"data: {chunk.model_dump_json(exclude_unset=True)}\n\n"
                         first_iteration[idx] = False
@@ -286,15 +292,17 @@ async def completion_stream_generator(
 
                     output = res["outputs"]
 
-                    choices.append(CompletionResponseStreamChoice(
-                        index=idx,
-                        text=output["text"],
-                        prompt_token_ids=None,
-                        completion_token_ids=output.get("token_ids") if enable_return_token_ids else None,
-                        tool_calls=output.get("tool_call_content"),
-                        reasoning_content=output.get("reasoning_content"),
-                        arrival_time=arrival_time
-                    ))
+                    choices.append(
+                        CompletionResponseStreamChoice(
+                            index=idx,
+                            text=output["text"],
+                            prompt_token_ids=None,
+                            completion_token_ids=(output.get("token_ids") if enable_return_token_ids else None),
+                            tool_calls=output.get("tool_call_content"),
+                            reasoning_content=output.get("reasoning_content"),
+                            arrival_time=arrival_time,
+                        )
+                    )
                     if res["finished"]:
                         if request.max_tokens is None or output_tokens[idx] + 1 != request.max_tokens:
                             chunk.choices[0].finish_reason = "stop"
@@ -353,12 +361,14 @@ def request_output_to_completion_response(
         created_time: int,
         model_name: str,
         prompt_batched_token_ids: list(),
-        completion_batched_token_ids: list()
+        completion_batched_token_ids: list(),
     ) -> CompletionResponse:
         choices: List[CompletionResponseChoice] = []
         num_prompt_tokens = 0
         num_generated_tokens = 0
-        enable_return_token_ids = request.return_token_ids or (request.extra_body is not None and request.extra_body.get('return_token_ids', False))
+        enable_return_token_ids = request.return_token_ids or (
+            request.extra_body is not None and request.extra_body.get("return_token_ids", False)
+        )
 
         for idx in range(len(final_res_batch)):
             final_res = final_res_batch[idx]
@@ -385,8 +395,8 @@ def request_output_to_completion_response(
                 index=len(choices),
                 text=output_text,
                 prompt_token_ids=prompt_token_ids if enable_return_token_ids else None,
-                completion_token_ids=completion_token_ids if enable_return_token_ids else None,
-                reasoning_content=output.get('reasoning_content'),
+                completion_token_ids=(completion_token_ids if enable_return_token_ids else None),
+                reasoning_content=output.get("reasoning_content"),
                 tool_calls=output.get("tool_call_content"),
                 logprobs=None,
                 finish_reason=None,

fastdeploy/input/ernie_processor.py

@@ -99,8 +99,7 @@ def process_request(self, request, max_model_len=None, **kwargs):
 
         if request.prompt_token_ids is None or len(request.prompt_token_ids) == 0:
             if request.prompt is None and request.messages is None:
-                raise ValueError(
-                    f"The request should have `prompt_token_ids`, `prompt` or `messages`: {request}.")
+                raise ValueError(f"The request should have `prompt_token_ids`, `prompt` or `messages`: {request}.")
             if request.prompt is not None:
                 prompt = request.prompt if request.prompt is not None else request.messages[0]
                 prompt = prompt[0] if isinstance(prompt, list) else prompt
@@ -164,8 +163,8 @@ def process_request_dict(self, request, max_model_len=None):
                 req_id = request.get("request_id", None)
                 data_processor_logger.info(f"req_id:{req_id}, tokens:{tokens}, token_ids: {token_ids}")
             else:
-                request['prompt_token_ids'] = self.messages2ids(request)
-        if len(request['prompt_token_ids']) == 0:
+                request["prompt_token_ids"] = self.messages2ids(request)
+        if len(request["prompt_token_ids"]) == 0:
             raise ValueError("Invalid input: prompt_token_ids must be a non-empty sequence of token IDs")
 
         # truncate prompts that exceed the length limit
@@ -246,8 +245,7 @@ def process_response_dict_normal(self, response_dict, **kwargs):
         if is_end:
             full_text = previous_texts + delta_text
             if enable_thinking and self.reasoning_parser:
-                reasoning_content, text = self.reasoning_parser.extract_reasoning_content(
-                    full_text, response_dict)
+                reasoning_content, text = self.reasoning_parser.extract_reasoning_content(full_text, response_dict)
                 response_dict["outputs"]["text"] = text
                 response_dict["outputs"]["reasoning_content"] = reasoning_content
             else:

fastdeploy/input/mm_processor/process.py

@@ -507,5 +507,6 @@ def apply_chat_template(self, request):
         tokens = self.tokenizer.tokenize(prompt_token_str)
         token_ids = self.tokenizer.convert_tokens_to_ids(tokens)
         data_processor_logger.info(
-            f"req_id:{request.get('request_id', ''),} tokens: {tokens}, token_ids: {token_ids}")
+            f"req_id:{request.get('request_id', ''), } tokens: {tokens}, token_ids: {token_ids}"
+        )
         return token_ids

fastdeploy/input/text_processor.py

@@ -239,9 +239,7 @@ def process_request(self, request, max_model_len=None, **kwargs):
                 task["enable_thinking"] = kwargs.get("enable_thinking", True)
                 request.prompt_token_ids = self.messages2ids(task)
             else:
-                raise ValueError(
-                    f"The request should have `input_ids`, `text` or `messages`: {request}."
-                )
+                raise ValueError(f"The request should have `input_ids`, `text` or `messages`: {request}.")
         if len(request.prompt_token_ids) == 0:
             raise ValueError("Invalid input: prompt_token_ids must be a non-empty sequence of token IDs")
         if request.get("max_tokens") is None:
@@ -281,18 +279,16 @@ def process_request_dict(self, request, max_model_len=None, **kwargs):
 
         data_processor_logger.info(f"Processing request {request}")
         # processing prompt_token_ids
-        if not request.get('prompt_token_ids'):
-            if 'prompt' in request:
-                request['prompt_token_ids'] = self.text2ids(request['prompt'], max_model_len).tolist()
-            elif 'messages' in request:
+        if not request.get("prompt_token_ids"):
+            if "prompt" in request:
+                request["prompt_token_ids"] = self.text2ids(request["prompt"], max_model_len).tolist()
+            elif "messages" in request:
                 if self.tokenizer.chat_template is None:
                     raise ValueError("This model does not support chat_template.")
                 request["prompt_token_ids"] = self.messages2ids(request)
             else:
-                raise ValueError(
-                    f"Request must contain 'prompt_token_ids', 'prompt', or 'messages': {request}"
-                )
-        if len(request['prompt_token_ids']) == 0:
+                raise ValueError(f"Request must contain 'prompt_token_ids', 'prompt', or 'messages': {request}")
+        if len(request["prompt_token_ids"]) == 0:
             raise ValueError("Invalid input: prompt_token_ids must be a non-empty sequence of token IDs")
         if request.get("max_tokens") is None:
             request["max_tokens"] = max(1, max_model_len - len(request["prompt_token_ids"]))
@@ -357,8 +353,7 @@ def process_response_dict_normal(self, response_dict, **kwargs):
         if is_end:
             full_text = previous_texts + delta_text
             if enable_thinking and self.reasoning_parser:
-                reasoning_content, text = self.reasoning_parser.extract_reasoning_content(
-                    full_text, response_dict)
+                reasoning_content, text = self.reasoning_parser.extract_reasoning_content(full_text, response_dict)
                 response_dict["outputs"]["text"] = text
                 response_dict["outputs"]["reasoning_content"] = reasoning_content
             else: