SYMBOL INDEX (370 symbols across 52 files)

FILE: gpt_server/cli.py
  function ui (line 13) | def ui(
  function main (line 25) | def main():

FILE: gpt_server/database/models/process_manager.py
  class ProcessRecord (line 12) | class ProcessRecord(SQLModel, table=True):
  class ProcessManager (line 24) | class ProcessManager:
    method __init__ (line 25) | def __init__(self, write_db: bool = False, db_url: str = "sqlite:///pr...
    method add_process (line 42) | def add_process(
    method start_all (line 64) | def start_all(self):
    method join_all (line 87) | def join_all(self):

FILE: gpt_server/model_backend/base.py
  class ModelBackend (line 5) | class ModelBackend(ABC):
    method stream_chat (line 7) | def stream_chat(self, params: Dict[str, Any]):
    method shutdown (line 10) | def shutdown(self):

FILE: gpt_server/model_backend/hf_backend.py
  class NoneContextManager (line 22) | class NoneContextManager:
    method __enter__ (line 23) | def __enter__(self):
    method __exit__ (line 26) | def __exit__(self, exc_type, exc_val, exc_tb):
  class HFBackend (line 30) | class HFBackend(ModelBackend):
    method __init__ (line 31) | def __init__(self, tokenizer: PreTrainedTokenizer, model: torch.nn.Mod...
    method shutdown (line 57) | def shutdown(self):
    method stream_chat (line 60) | async def stream_chat(self, params: Dict[str, Any]):

FILE: gpt_server/model_backend/lmdeploy_backend.py
  class CustomRequestLogger (line 40) | class CustomRequestLogger(RequestLogger):
    method log_prompt (line 41) | def log_prompt(self, session_id: int, prompt: str) -> None:
    method log_inputs (line 47) | def log_inputs(
  class LMDeployBackend (line 70) | class LMDeployBackend(ModelBackend):
    method __init__ (line 71) | def __init__(self, model_path, tokenizer: PreTrainedTokenizer) -> None:
    method shutdown (line 106) | def shutdown(self):
    method stream_chat (line 109) | async def stream_chat(self, params: Dict[str, Any]) -> AsyncGenerator:

FILE: gpt_server/model_backend/sglang_backend.py
  class CustomOpenAIServingResponses (line 29) | class CustomOpenAIServingResponses(OpenAIServingResponses):
    method _process_messages (line 30) | def _process_messages(self, request, is_multimodal):
  class CustomOpenAIServingChat (line 39) | class CustomOpenAIServingChat(OpenAIServingChat):
    method _process_messages (line 40) | def _process_messages(self, request, is_multimodal):
  class SGLangBackend (line 49) | class SGLangBackend(ModelBackend):
    method __init__ (line 50) | def __init__(self, model_path, tokenizer: PreTrainedTokenizer) -> None:
    method shutdown (line 91) | def shutdown(self):
    method stream_chat (line 94) | async def stream_chat(self, params: Dict[str, Any]) -> AsyncGenerator:

FILE: gpt_server/model_backend/utils.py
  class XgrammarLogitsProcessor (line 15) | class XgrammarLogitsProcessor(LogitsProcessor):
    method __init__ (line 16) | def __init__(self, tokenizer: PreTrainedTokenizerBase):
    method get_json_grammar_processor (line 21) | def get_json_grammar_processor(self):
    method get_json_schema_processor (line 26) | def get_json_schema_processor(self, schema: Union[str, Type[BaseModel]]):
    method __call__ (line 31) | def __call__(
  class InvalidScoreLogitsProcessor (line 37) | class InvalidScoreLogitsProcessor(LogitsProcessor):
    method __call__ (line 38) | def __call__(
  class StopAtSpecificTokenCriteria (line 47) | class StopAtSpecificTokenCriteria(StoppingCriteria):
    method __init__ (line 52) | def __init__(self, token_id_list: List[int] = None):
    method __call__ (line 60) | def __call__(

FILE: gpt_server/model_backend/vllm_backend.py
  class CustomOpenAIServingResponses (line 24) | class CustomOpenAIServingResponses(OpenAIServingResponses):
    method _preprocess_chat (line 25) | async def _preprocess_chat(self, *args, **kwargs):
  class CustomOpenAIServingChat (line 36) | class CustomOpenAIServingChat(OpenAIServingChat):
    method render_chat_request (line 37) | async def render_chat_request(self, request):
  class VllmBackend (line 47) | class VllmBackend(ModelBackend):
    method __init__ (line 48) | def __init__(self, model_path, tokenizer: PreTrainedTokenizer) -> None:
    method shutdown (line 126) | def shutdown(self):
    method stream_chat (line 130) | async def stream_chat(self, params: Dict[str, Any]) -> AsyncGenerator:

FILE: gpt_server/model_handler/chat_template/get_chat_template.py
  function get_chat_template (line 7) | def get_chat_template(model_name: str = "", lang: Literal["en", "zh"] = ...

FILE: gpt_server/model_handler/pitch.py
  class VllmGenerator_ (line 7) | class VllmGenerator_(VllmGenerator):
    method __init__ (line 8) | def __init__(
  function pitch_flashtts (line 41) | def pitch_flashtts():

FILE: gpt_server/model_handler/reasoning_parser.py
  class DeepSeekR1ReasoningParser (line 15) | class DeepSeekR1ReasoningParser(ReasoningParser):
    method __init__ (line 22) | def __init__(self, tokenizer: object):
    method extract_reasoning_content_streaming (line 45) | def extract_reasoning_content_streaming(
    method extract_reasoning_content (line 126) | def extract_reasoning_content(

FILE: gpt_server/model_handler/tool_parser.py
  class ToolCall (line 16) | class ToolCall(BaseModel):
  class ExtractedToolCallInformation (line 25) | class ExtractedToolCallInformation(BaseModel):
  class Qwen2d5ToolParser (line 37) | class Qwen2d5ToolParser(ToolParser):
    method __init__ (line 38) | def __init__(self, tokenizer: object):
    method extract_tool_calls (line 45) | def extract_tool_calls(
  function tool_parser (line 122) | def tool_parser(full_text: str, tool_parser_: ToolParser, tools, ret):
  class ToolCallStreamProcessor (line 165) | class ToolCallStreamProcessor:
    method __init__ (line 170) | def __init__(self):
    method process_chunk (line 174) | def process_chunk(self, tool_calls_data: List[Dict]) -> Optional[List[...
    method get_completed_tool_calls (line 211) | def get_completed_tool_calls(self) -> Optional[List[Dict]]:
    method reset (line 245) | def reset(self):

FILE: gpt_server/model_worker/__init__.py
  function patch_infinity_embedder (line 8) | def patch_infinity_embedder():
  function patch_infinity_crossencoder (line 37) | def patch_infinity_crossencoder():

FILE: gpt_server/model_worker/auto.py
  class AutoWorker (line 16) | class AutoWorker(ModelWorkerBase):
    method __init__ (line 17) | def __init__(
    method generate_stream_gate (line 54) | async def generate_stream_gate(self, params):

FILE: gpt_server/model_worker/base/base_model_worker.py
  function build_logger (line 13) | def build_logger():
  function heart_beat_worker (line 25) | def heart_beat_worker(obj: "BaseModelWorker"):
  class BaseModelWorker (line 31) | class BaseModelWorker:
    method __init__ (line 32) | def __init__(
    method make_conv_template (line 67) | def make_conv_template(
    method init_heart_beat (line 84) | def init_heart_beat(self):
    method register_to_controller (line 93) | def register_to_controller(self):
    method send_heart_beat (line 106) | def send_heart_beat(self):
    method get_queue_length (line 129) | def get_queue_length(self):
    method get_status (line 143) | def get_status(self):
    method count_token (line 150) | def count_token(self, params):
    method get_conv_template (line 165) | def get_conv_template(self):
    method generate_stream_gate (line 168) | def generate_stream_gate(self, params):
    method generate_gate (line 171) | def generate_gate(self, params):
    method get_embeddings (line 174) | def get_embeddings(self, params):
    method classify (line 177) | def classify(self, params):
    method transcription (line 180) | def transcription(self, params):
    method generate_voice_stream (line 183) | def generate_voice_stream(self, params):
    method get_image_output (line 186) | def get_image_output(self, params):

FILE: gpt_server/model_worker/base/model_worker_base.py
  function get_context_length_ (line 34) | def get_context_length_(config):
  function cleanup_static_files (line 52) | async def cleanup_static_files():
  function run_scheduler (line 62) | async def run_scheduler():
  function pop_matching_tool (line 69) | def pop_matching_tool(tools, tool_choice):
  class ModelWorkerBase (line 82) | class ModelWorkerBase(BaseModelWorker, ABC):
    method __init__ (line 83) | def __init__(
    method preprocess_params (line 141) | def preprocess_params(self, params: dict) -> dict:
    method get_context_length (line 176) | def get_context_length(
    method get_model_class (line 184) | def get_model_class(self):
    method load_model_tokenizer (line 199) | def load_model_tokenizer(self, model_path):
    method generate_gate (line 247) | async def generate_gate(self, params):
    method get_worker (line 272) | def get_worker(
    method run (line 294) | def run(cls):
  function release_worker_semaphore (line 426) | def release_worker_semaphore():
  function acquire_worker_semaphore (line 430) | def acquire_worker_semaphore():
  function create_background_tasks (line 436) | def create_background_tasks(request_id):
  function gen_request_id (line 446) | def gen_request_id():
  function api_generate_stream (line 453) | async def api_generate_stream(request: Request):
  function api_generate_stream (line 468) | async def api_generate_stream(request: Request):
  function api_generate (line 500) | async def api_generate(request: Request):
  function api_get_status (line 517) | async def api_get_status(request: Request):
  function api_count_token (line 522) | async def api_count_token(request: Request):
  function api_get_conv (line 528) | async def api_get_conv(request: Request):
  function api_model_details (line 533) | async def api_model_details(request: Request):
  function api_get_embeddings (line 538) | async def api_get_embeddings(request: Request):
  function api_get_embeddings (line 548) | async def api_get_embeddings(request: Request):
  function api_get_classify (line 558) | async def api_get_classify(request: Request):
  function api_get_transcription (line 568) | async def api_get_transcription(request: Request):

FILE: gpt_server/model_worker/embedding_infinity.py
  class EmbeddingWorker (line 24) | class EmbeddingWorker(ModelWorkerBase):
    method __init__ (line 25) | def __init__(
    method astart (line 70) | async def astart(self):
    method get_embeddings (line 73) | async def get_embeddings(self, params):
    method classify (line 115) | async def classify(self, params):

FILE: gpt_server/model_worker/embedding_sentence_transformers.py
  class EmbeddingWorker (line 11) | class EmbeddingWorker(ModelWorkerBase):
    method __init__ (line 12) | def __init__(
    method get_embeddings (line 40) | async def get_embeddings(self, params):

FILE: gpt_server/model_worker/embedding_v2.py
  class EmbeddingWorker (line 10) | class EmbeddingWorker(ModelWorkerBase):
    method __init__ (line 11) | def __init__(
    method warm_up (line 67) | def warm_up(self):
    method batch_processor (line 74) | async def batch_processor(self):
    method add_request (line 132) | async def add_request(self, params: dict, future: asyncio.Future):
    method aembed (line 136) | async def aembed(self, params: dict, future: asyncio.Future):
    method rerank (line 139) | async def rerank(self, params: dict, future: asyncio.Future):
    method get_embeddings (line 142) | async def get_embeddings(self, params):

FILE: gpt_server/model_worker/embedding_vllm.py
  function template_format (line 24) | def template_format(queries: List[str], documents: List[str]):
  class EmbeddingWorker (line 42) | class EmbeddingWorker(ModelWorkerBase):
    method __init__ (line 43) | def __init__(
    method get_embeddings (line 82) | async def get_embeddings(self, params):

FILE: gpt_server/model_worker/flux.py
  class FluxWorker (line 18) | class FluxWorker(ModelWorkerBase):
    method __init__ (line 19) | def __init__(
    method get_image_output (line 47) | async def get_image_output(self, params):

FILE: gpt_server/model_worker/funasr.py
  class FunASRWorker (line 11) | class FunASRWorker(ModelWorkerBase):
    method __init__ (line 12) | def __init__(
    method transcription (line 48) | async def transcription(self, params):

FILE: gpt_server/model_worker/qwen_image.py
  function contains_chinese (line 34) | def contains_chinese(text):
  class QwenImageWorker (line 39) | class QwenImageWorker(ModelWorkerBase):
    method __init__ (line 40) | def __init__(
    method get_image_output (line 68) | async def get_image_output(self, params):

FILE: gpt_server/model_worker/qwen_image_edit.py
  class QwenImageEditWorker (line 21) | class QwenImageEditWorker(ModelWorkerBase):
    method __init__ (line 22) | def __init__(
    method get_image_output (line 49) | async def get_image_output(self, params):

FILE: gpt_server/model_worker/spark_tts.py
  class SparkTTSWorker (line 18) | class SparkTTSWorker(ModelWorkerBase):
    method __init__ (line 19) | def __init__(
    method generate_voice_stream (line 66) | async def generate_voice_stream(self, params):
    method stream_async (line 72) | async def stream_async(self, params):

FILE: gpt_server/model_worker/utils.py
  function is_base64_image (line 15) | def is_base64_image(data_string):
  function pil_to_base64 (line 21) | def pil_to_base64(pil_img: Image.Image, format: str = "PNG"):
  function _extract_base64 (line 27) | def _extract_base64(data_url: str):
  function _get_bytes_from_url (line 32) | async def _get_bytes_from_url(url: str) -> bytes:
  function bytesio2image (line 40) | def bytesio2image(bytes_io: io.BytesIO) -> Image.Image:
  function bytes2image (line 44) | def bytes2image(bytes_: bytes) -> Image.Image:
  function load_base64_or_url (line 49) | async def load_base64_or_url(base64_or_url) -> io.BytesIO:
  function guess_tool_parser_by_model (line 70) | def guess_tool_parser_by_model(model_path: str) -> str:
  class PoolingModel (line 88) | class PoolingModel:
    method __init__ (line 89) | def __init__(self, model_path: str):
    method pooling (line 200) | def pooling(self, query, documents):
  function patch (line 206) | def patch():
  function get_embedding_mode (line 216) | def get_embedding_mode(model_path: str):

FILE: gpt_server/model_worker/voxcpm_tts.py
  class VoxCPMTTSWorker (line 16) | class VoxCPMTTSWorker(ModelWorkerBase):
    method __init__ (line 17) | def __init__(
    method generate_voice_stream (line 41) | async def generate_voice_stream(self, params):
    method stream_async (line 47) | async def stream_async(self, params):

FILE: gpt_server/model_worker/wan.py
  class WanWorker (line 19) | class WanWorker(ModelWorkerBase):
    method __init__ (line 20) | def __init__(
    method get_image_output (line 50) | async def get_image_output(self, params):

FILE: gpt_server/model_worker/z_image.py
  function contains_chinese (line 29) | def contains_chinese(text):
  class ZImageWorker (line 34) | class ZImageWorker(ModelWorkerBase):
    method __init__ (line 35) | def __init__(
    method get_image_output (line 63) | async def get_image_output(self, params):

FILE: gpt_server/openai_api_protocol/custom_api_protocol.py
  class UsageInfo (line 68) | class UsageInfo(BaseModel):
  class ErrorInfo (line 77) | class ErrorInfo(BaseModel):
  class ErrorResponseV2 (line 84) | class ErrorResponseV2(BaseModel):
  class InputTokensDetails (line 88) | class InputTokensDetails(BaseModel):
  class OutputTokensDetails (line 94) | class OutputTokensDetails(BaseModel):
  class ResponseUsage (line 100) | class ResponseUsage(BaseModel):
  class ResponseReasoningParam (line 108) | class ResponseReasoningParam(BaseModel):
  class RequestResponseMetadata (line 117) | class RequestResponseMetadata(BaseModel):
  class ResponsesRequest (line 122) | class ResponsesRequest(BaseModel):
  class ResponsesResponse (line 183) | class ResponsesResponse(BaseModel):
    method from_request (line 219) | def from_request(
  class ImagesGenRequest (line 262) | class ImagesGenRequest(BaseModel):
  class OpenAISpeechRequest (line 281) | class OpenAISpeechRequest(BaseModel):
  class SpeechRequest (line 313) | class SpeechRequest(BaseModel):
  class ModerationsRequest (line 337) | class ModerationsRequest(BaseModel):
  class RerankRequest (line 343) | class RerankRequest(BaseModel):
  class EmbeddingsResponse (line 352) | class EmbeddingsResponse(BaseModel):
  class ModelPermission (line 359) | class ModelPermission(BaseModel):
  class CustomModelCard (line 374) | class CustomModelCard(BaseModel):
  class ModelList (line 384) | class ModelList(BaseModel):
  class CustomEmbeddingsRequest (line 389) | class CustomEmbeddingsRequest(BaseModel):
  class CustomChatCompletionRequest (line 398) | class CustomChatCompletionRequest(BaseModel):
  class ChatMessage (line 423) | class ChatMessage(BaseModel):
  class CustomChatMessage (line 428) | class CustomChatMessage(ChatMessage):
  class CustomChatCompletionResponseChoice (line 433) | class CustomChatCompletionResponseChoice(BaseModel):
  class LogProbs (line 439) | class LogProbs(BaseModel):
  class CustomCompletionResponseChoice (line 446) | class CustomCompletionResponseChoice(BaseModel):
  class CustomChatCompletionResponse (line 456) | class CustomChatCompletionResponse(BaseModel):
  class CustomDeltaMessage (line 466) | class CustomDeltaMessage(BaseModel):
  class CustomChatCompletionResponseStreamChoice (line 473) | class CustomChatCompletionResponseStreamChoice(BaseModel):
  class CustomChatCompletionStreamResponse (line 479) | class CustomChatCompletionStreamResponse(BaseModel):
  class CompletionResponse (line 488) | class CompletionResponse(BaseModel):

FILE: gpt_server/serving/chat_ui.py
  function clear_chat_history (line 37) | def clear_chat_history():
  function init_chat_history (line 41) | def init_chat_history():
  function main (line 56) | def main():

FILE: gpt_server/serving/controller.py
  class DispatchMethod (line 32) | class DispatchMethod(Enum):
    method from_str (line 37) | def from_str(cls, name):
  class WorkerInfo (line 47) | class WorkerInfo:
  function heart_beat_controller (line 56) | def heart_beat_controller(controller):
  class Controller (line 62) | class Controller:
    method __init__ (line 63) | def __init__(self, dispatch_method: str):
    method register_worker (line 73) | def register_worker(
    method get_worker_status (line 102) | def get_worker_status(self, worker_name: str):
    method remove_worker (line 115) | def remove_worker(self, worker_name: str):
    method refresh_all_workers (line 118) | def refresh_all_workers(self):
    method list_models (line 128) | def list_models(self):
    method list_multimodal_models (line 136) | def list_multimodal_models(self):
    method list_language_models (line 145) | def list_language_models(self):
    method get_worker_address (line 207) | def get_worker_address(self, model_name: str):
    method receive_heart_beat (line 215) | def receive_heart_beat(self, worker_name: str, queue_length: int):
    method remove_stale_workers_by_expiration (line 225) | def remove_stale_workers_by_expiration(self):
    method handle_no_worker (line 235) | def handle_no_worker(self, params):
    method handle_worker_timeout (line 243) | def handle_worker_timeout(self, worker_address):
    method worker_api_get_status (line 253) | def worker_api_get_status(self):
    method worker_api_generate_stream (line 272) | def worker_api_generate_stream(self, params):
  function register_worker (line 295) | async def register_worker(request: Request):
  function refresh_all_workers (line 306) | async def refresh_all_workers():
  function list_models (line 311) | async def list_models():
  function list_multimodal_models (line 317) | async def list_multimodal_models():
  function list_language_models (line 323) | async def list_language_models():
  function get_worker_address (line 329) | async def get_worker_address(request: Request):
  function receive_heart_beat (line 336) | async def receive_heart_beat(request: Request):
  function worker_api_generate_stream (line 343) | async def worker_api_generate_stream(request: Request):
  function worker_api_get_status (line 350) | async def worker_api_get_status(request: Request):
  function worker_api_get_status (line 355) | async def worker_api_get_status(request: Request):
  function create_controller (line 359) | def create_controller():

FILE: gpt_server/serving/controller_v2.py
  class DispatchMethod (line 34) | class DispatchMethod(Enum):
    method from_str (line 39) | def from_str(cls, name):
  class Worker (line 50) | class Worker(SQLModel, table=True):
  function create_db_and_tables (line 72) | def create_db_and_tables():
  function heart_beat_controller (line 79) | def heart_beat_controller(controller: "Controller"):
  class Controller (line 86) | class Controller:
    method __init__ (line 87) | def __init__(self, dispatch_method: str, db_engine):
    method get_session (line 97) | def get_session(self):
    method register_worker (line 101) | def register_worker(
    method get_worker_status (line 147) | def get_worker_status(self, worker_addr: str):
    method remove_worker (line 161) | def remove_worker(self, worker_addr: str):
    method refresh_all_workers (line 174) | def refresh_all_workers(self):
    method list_models (line 196) | def list_models(self):
    method list_multimodal_models (line 207) | def list_multimodal_models(self):
    method list_language_models (line 217) | def list_language_models(self):
    method get_worker_address (line 227) | def get_worker_address(self, model_name: str):
    method receive_heart_beat (line 242) | def receive_heart_beat(self, worker_addr: str, queue_length: int):
    method remove_stale_workers_by_expiration (line 257) | def remove_stale_workers_by_expiration(self):
    method handle_no_worker (line 278) | def handle_no_worker(self, params):
    method handle_worker_timeout (line 287) | def handle_worker_timeout(self, worker_address):
  function register_worker (line 301) | async def register_worker(request: Request):
  function refresh_all_workers (line 312) | async def refresh_all_workers():
  function list_models (line 317) | async def list_models():
  function list_multimodal_models (line 323) | async def list_multimodal_models():
  function list_language_models (line 329) | async def list_language_models():
  function get_worker_address (line 335) | async def get_worker_address(request: Request):
  function receive_heart_beat (line 342) | async def receive_heart_beat(request: Request):
  function worker_api_get_status (line 350) | async def worker_api_get_status(request: Request):
  function create_controller (line 354) | def create_controller(db_engine_to_use):

FILE: gpt_server/serving/main.py
  function get_enabled_models (line 43) | def get_enabled_models(config):
  function main (line 57) | def main():

FILE: gpt_server/serving/openai_api_server.py
  function fetch_remote (line 64) | async def fetch_remote(url, pload=None, name=None):
  class AppSettings (line 88) | class AppSettings(BaseSettings):
    method split_api_keys (line 94) | def split_api_keys(cls, v):
    class Config (line 99) | class Config:
      method parse_env_var (line 102) | def parse_env_var(cls, field_name: str, raw_val: str):
  function timing_tasks (line 113) | async def timing_tasks():
  function lifespan (line 143) | async def lifespan(app: fastapi.FastAPI):
  function check_api_key (line 154) | async def check_api_key(
  function create_error_response (line 176) | def create_error_response(code: int, message: str) -> JSONResponse:
  function validation_exception_handler (line 183) | async def validation_exception_handler(request: Request, exc: RequestVal...
  function check_model (line 187) | def check_model(model: str) -> Optional[JSONResponse]:
  function process_input (line 199) | def process_input(model_name, inp):
  function create_openai_logprobs (line 223) | def create_openai_logprobs(logprob_dict):
  function _add_to_set (line 228) | def _add_to_set(s, new_stop):
  function get_gen_params (line 237) | def get_gen_params(
  class AddressManager (line 302) | class AddressManager:
    method __init__ (line 303) | def __init__(self):
    method get_address (line 307) | def get_address(self, model):
  function get_worker_address (line 329) | def get_worker_address(model_name: str) -> str:
  function get_conv (line 348) | async def get_conv(model_name: str, worker_addr: str):
  function show_available_models (line 370) | async def show_available_models():
  function get_model_address_map (line 408) | def get_model_address_map():
  function create_responses (line 418) | async def create_responses(request: ResponsesRequest):
  function create_chat_completion (line 460) | async def create_chat_completion(request: CustomChatCompletionRequest):
  function chat_completion_stream_generator (line 547) | async def chat_completion_stream_generator(
  function create_completion (line 603) | async def create_completion(request: CompletionRequest):
  function generate_completion_stream_generator (line 674) | async def generate_completion_stream_generator(
  function generate_completion_stream (line 733) | async def generate_completion_stream(payload: Dict[str, Any], worker_add...
  function generate_completion (line 754) | async def generate_completion(payload: Dict[str, Any], worker_addr: str):
  function get_images_edits (line 769) | async def get_images_edits(payload: Dict[str, Any]):
  function images_edits (line 780) | async def images_edits(
  function get_images_gen (line 812) | async def get_images_gen(payload: Dict[str, Any]):
  function images_generations (line 823) | async def images_generations(request: ImagesGenRequest):
  function generate_voice_stream (line 845) | async def generate_voice_stream(payload: Dict[str, Any], worker_addr: str):
  function speech (line 862) | async def speech(request: OpenAISpeechRequest):
  function get_transcriptions (line 908) | async def get_transcriptions(payload: Dict[str, Any]):
  function transcriptions (line 924) | async def transcriptions(file: UploadFile, model: str = Form()):
  function classify (line 952) | async def classify(request: ModerationsRequest):
  function rerank (line 995) | async def rerank(request: RerankRequest):
  function create_embeddings (line 1038) | async def create_embeddings(request: CustomEmbeddingsRequest, model_name...
  function get_classify (line 1085) | async def get_classify(payload: Dict[str, Any]):
  function get_embedding (line 1094) | async def get_embedding(payload: Dict[str, Any]):
  function count_tokens (line 1107) | async def count_tokens(request: APITokenCheckRequest):
  function create_openai_api_server (line 1141) | def create_openai_api_server():

FILE: gpt_server/serving/server_ui.py
  function get_process_num (line 26) | def get_process_num():
  function update_config (line 37) | def update_config(config: dict):
  function serve_args (line 58) | def serve_args():
  function controller_args (line 82) | def controller_args():
  function model_worker_args (line 101) | def model_worker_args():

FILE: gpt_server/settings.py
  class ModelConfig (line 4) | class ModelConfig(BaseSettings):
  function get_model_config (line 27) | def get_model_config() -> ModelConfig:

FILE: gpt_server/utils.py
  function _register (line 29) | def _register(group: str, proc: subprocess.Popen):
  function _kill_tree (line 33) | def _kill_tree(pid: int, timeout: int = 5):
  function _graceful_shutdown (line 57) | def _graceful_shutdown():
  function clear_flashinfer_cache (line 66) | def clear_flashinfer_cache():
  function delete_flash_attn (line 70) | def delete_flash_attn():
  function pre_processing (line 95) | def pre_processing():
  function signal_handler (line 108) | def signal_handler(signum, frame):
  function run_cmd (line 117) | def run_cmd(cmd: str, group: str = "worker") -> subprocess.Popen:
  function start_controller (line 126) | def start_controller(controller_host, controller_port, dispatch_method):
  function start_openai_server (line 136) | def start_openai_server(host, port, controller_address, api_keys=None):
  function start_api_server (line 148) | def start_api_server(config: dict):
  function get_model_types (line 179) | def get_model_types():
  function start_model_worker (line 197) | def start_model_worker(config: dict):
  function start_server (line 370) | def start_server(
  function delete_log (line 398) | def delete_log():
  function get_free_tcp_port (line 412) | def get_free_tcp_port():
  function is_port_in_use (line 421) | def is_port_in_use(port: int):
  function get_physical_ip (line 430) | def get_physical_ip():

FILE: gpt_server/version.py
  function parse_version_info (line 7) | def parse_version_info(version_str: str) -> Tuple:

FILE: setup.py
  function readme (line 9) | def readme():
  function get_version (line 15) | def get_version():

FILE: tests/download_model.py
  function model_download (line 10) | def model_download(model_id, local_dir="/data", hub_name="hf", repo_type...

FILE: tests/responses_api/test_openai_responses_response_format.py
  class Distance (line 28) | class Distance(BaseModel):

FILE: tests/responses_api/test_openai_responses_tool_calling.py
  function get_weather (line 6) | def get_weather(location: str, unit: str = "2") -> str:
  function main (line 35) | def main():

FILE: tests/sglang/models.py
  class CustomOpenAIServingChat (line 25) | class CustomOpenAIServingChat(OpenAIServingChat):
    method _process_messages (line 26) | def _process_messages(self, request, is_multimodal):
  function main (line 33) | async def main():

FILE: tests/test_embedding_dynamic_batch.py
  function f (line 6) | async def f():
  function main (line 17) | async def main():

FILE: tests/test_openai_completion_response_format.py
  class Distance (line 28) | class Distance(BaseModel):

FILE: tests/test_openai_completion_tool_calling.py
  function get_weather (line 8) | def get_weather(location: str, unit: str = "celsius"):

FILE: tests/test_openai_embedding_vl.py
  function image_to_base64 (line 14) | def image_to_base64(image_path):

FILE: tests/test_openai_vl_chat.py
  function image_to_base64 (line 6) | def image_to_base64(image_path):

FILE: tests/test_rerank.py
  function rerank (line 7) | def rerank():

FILE: tests/vllm/embedding.py
  function main (line 19) | async def main():

FILE: tests/vllm/models.py
  class CustomOpenAIServingChat (line 18) | class CustomOpenAIServingChat(OpenAIServingChat):
    method render_chat_request (line 19) | async def render_chat_request(self, request):
  function main (line 51) | async def main():