format

vllm/entrypoints/openai/api_server.py

@@ -60,12 +60,14 @@
 
 _running_tasks: Set[asyncio.Task] = set()
 
+
 def model_is_embedding(model_name: str) -> bool:
     return ModelConfig(model=model_name,
                        tokenizer=model_name,
                        tokenizer_mode="auto",
                        trust_remote_code=False,
-                       seed=0, dtype="float16").embedding_mode
+                       seed=0,
+                       dtype="float16").embedding_mode
 
 
 @asynccontextmanager
@@ -94,27 +96,26 @@ async def build_async_engine_client(args) -> AsyncIterator[AsyncEngineClient]:
     # Backend itself still global for the silly lil' health handler
     global async_engine_client
 
-
     # If manually triggered or embedding model, use AsyncLLMEngine in process.
     # TODO: support embedding model via RPC.
-    if (model_is_embedding(args.model) or 
-        args.disable_frontend_multiprocessing):
+    if (model_is_embedding(args.model)
+            or args.disable_frontend_multiprocessing):
         async_engine_client = AsyncLLMEngine.from_engine_args(
             engine_args, usage_context=UsageContext.OPENAI_API_SERVER)
         yield async_engine_client
         return
 
     # Otherwise, use the multiprocessing AsyncLLMEngine.
     else:
-        # Start the RPC Server in separate process (holds the AsyncLLMEngine).
+        # Start RPCServer in separate process (holds the AsyncLLMEngine).
         port = get_open_port(envs.VLLM_RPC_PORT)
         rpc_server_process = Process(target=run_rpc_server,
                                      args=(engine_args,
                                            UsageContext.OPENAI_API_SERVER,
                                            port))
         rpc_server_process.start()
 
-        # Build the RPC Client, which conforms to the AsyncEngineClient protocol.
+        # Build RPCClient, which conforms to AsyncEngineClient Protocol.
         async_engine_client = AsyncEngineRPCClient(port)
         await async_engine_client.setup()
 

vllm/entrypoints/openai/serving_chat.py

@@ -89,7 +89,8 @@ async def create_chat_completion(
             ) = self._maybe_get_adapters(request)
 
             model_config = self.model_config
-            tokenizer = await self.async_engine_client.get_tokenizer(lora_request)
+            tokenizer = await self.async_engine_client.get_tokenizer(
+                lora_request)
 
             conversation: List[ConversationMessage] = []
             mm_futures: List[Awaitable[MultiModalDataDict]] = []
@@ -161,7 +162,8 @@ async def create_chat_completion(
             if mm_data is not None:
                 engine_inputs["multi_modal_data"] = mm_data
 
-            is_tracing_enabled = await self.async_engine_client.is_tracing_enabled()
+            is_tracing_enabled = (
+                await self.async_engine_client.is_tracing_enabled())
             trace_headers = None
             if is_tracing_enabled and raw_request:
                 trace_headers = extract_trace_headers(raw_request.headers)

vllm/entrypoints/openai/serving_completion.py

@@ -91,7 +91,8 @@ async def create_completion(self, request: CompletionRequest,
                 prompt_adapter_request,
             ) = self._maybe_get_adapters(request)
 
-            tokenizer = await self.async_engine_client.get_tokenizer(lora_request)
+            tokenizer = await self.async_engine_client.get_tokenizer(
+                lora_request)
 
             guided_decode_logits_processor = (
                 await self._guided_decode_logits_processor(request, tokenizer))
@@ -119,8 +120,8 @@ async def create_completion(self, request: CompletionRequest,
                                  lora_request=lora_request,
                                  prompt_adapter_request=prompt_adapter_request)
 
-                is_tracing_enabled = await self.async_engine_client.is_tracing_enabled(
-                )
+                is_tracing_enabled = (
+                    await self.async_engine_client.is_tracing_enabled())
                 trace_headers = None
                 if is_tracing_enabled:
                     trace_headers = extract_trace_headers(raw_request.headers)
@@ -231,7 +232,8 @@ async def completion_stream_generator(
 
                 # Abort the request if the client disconnects.
                 if await raw_request.is_disconnected():
-                    await self.async_engine_client.abort(f"{request_id}-{prompt_idx}")
+                    await self.async_engine_client.abort(
+                        f"{request_id}-{prompt_idx}")
                     raise StopAsyncIteration()
 
                 for output in res.outputs:

vllm/entrypoints/openai/serving_embedding.py

@@ -99,7 +99,8 @@ async def create_embedding(self, request: EmbeddingRequest,
                 prompt_adapter_request,
             ) = self._maybe_get_adapters(request)
 
-            tokenizer = await self.async_engine_client.get_tokenizer(lora_request)
+            tokenizer = await self.async_engine_client.get_tokenizer(
+                lora_request)
 
             pooling_params = request.to_pooling_params()
 

vllm/tracing.py

@@ -60,7 +60,7 @@ def get_span_exporter(endpoint):
             OTLPSpanExporter)
     elif protocol == "http/protobuf":
         from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
-            OTLPSpanExporter)
+            OTLPSpanExporter)  # type: ignore
     else:
         raise ValueError(
             f"Unsupported OTLP protocol '{protocol}' is configured")