class_docstr: An LLM engine that receives requests and generates texts.
  
  This is the main class for the vLLM engine. It receives requests
  from clients and generates texts from the LLM. It includes a tokenizer, a
  language model (possibly distributed across multiple GPUs), and GPU memory
  space allocated for intermediate states (aka KV cache). This class utilizes
  iteration-level scheduling and efficient memory management to maximize the
  serving throughput.
  
  The `LLM` class wraps this class for offline batched inference and the
  `AsyncLLMEngine` class wraps this class for online serving.
  
  NOTE: The config arguments are derived from the `EngineArgs` class. For the
  comprehensive list of arguments, see `EngineArgs`.
  
  Args:
      model_config: The configuration related to the LLM model.
      cache_config: The configuration related to the KV cache memory
          management.
      parallel_config: The configuration related to distributed execution.
      scheduler_config: The configuration related to the request scheduler.
      distributed_init_method: The initialization method for distributed
          execution. See `torch.distributed.init_process_group` for details.
      placement_group: Ray placement group for distributed execution.
          Required for distributed execution.
      log_stats: Whether to log statistics.
docstr: Stop the finished sequences.
docstr_tok: ["Stop","the","finished","sequences","."]
code: def _check_stop(
      self, seq: Sequence, sampling_params: SamplingParams
  ) -> None:
      """Stop the finished sequences."""
      for stop_str in sampling_params.stop:
          if seq.output_text.endswith(stop_str):
              # Truncate the output text so that the stop string is
              # not included in the output.
              seq.output_text = seq.output_text[: -len(stop_str)]
              seq.status = SequenceStatus.FINISHED_STOPPED
              return
      if seq.get_last_token_id() in sampling_params.stop_token_ids:
          seq.status = SequenceStatus.FINISHED_STOPPED
          return
  
      # Check if the sequence has reached max_model_len.
      if seq.get_len() > self.scheduler_config.max_model_len:
          seq.status = SequenceStatus.FINISHED_LENGTH_CAPPED
          return
  
      # Check if the sequence has reached max_tokens.
      if seq.get_output_len() == sampling_params.max_tokens:
          seq.status = SequenceStatus.FINISHED_LENGTH_CAPPED
          return
  
      # Check if the sequence has generated the EOS token.
      if (
          not sampling_params.ignore_eos
      ) and seq.get_last_token_id() == self.tokenizer.eos_token_id:
          seq.status = SequenceStatus.FINISHED_STOPPED
          return
  
imports: import time
  from typing import TYPE_CHECKING, Any, Iterable, List, Optional, Tuple, Union, Dict
  from bigdl.llm.vllm.config import ModelConfig, SchedulerConfig
  from bigdl.llm.vllm.core.scheduler import SchedulerOutputs, FixedWindowScheduler
  from bigdl.llm.vllm.engine.arg_utils import EngineArgs
  from bigdl.llm.vllm.logger import init_logger
  from bigdl.llm.vllm.outputs import RequestOutput
  from bigdl.llm.vllm.sampling_params import SamplingParams
  from bigdl.llm.vllm.sequence import SamplerOutput, Sequence, SequenceGroup, SequenceGroupMetadata, SequenceStatus, SequenceOutputs
  from bigdl.llm.vllm.transformers_utils.tokenizer import get_tokenizer, detokenize_incrementally
  from bigdl.llm.vllm.utils import Counter
  from bigdl.llm.utils.common import invalidInputError
label_desc: Use image node_id 17 for calling the LLMEngine obj's underlying member method code with example usage: obj._check_stop(seq, sampling_params) without return types