[CI] Try introducing isort. (#3495)

tests/lora/test_tokenizer_group.py

 import pytest
 from transformers import AutoTokenizer, PreTrainedTokenizerBase
+
 from vllm.lora.request import LoRARequest
-from vllm.transformers_utils.tokenizer_group import get_tokenizer_group
 from vllm.transformers_utils.tokenizer import get_lora_tokenizer
+from vllm.transformers_utils.tokenizer_group import get_tokenizer_group
+
 from ..conftest import get_tokenizer_pool_config
 
 

tests/lora/test_utils.py

@@ -2,8 +2,8 @@ from collections import OrderedDict
 
 from torch import nn
 
+from vllm.lora.utils import parse_fine_tuned_lora_name, replace_submodule
 from vllm.utils import LRUCache
-from vllm.lora.utils import (parse_fine_tuned_lora_name, replace_submodule)
 
 
 def test_parse_fine_tuned_lora_name():

tests/lora/test_worker.py

@@ -3,10 +3,10 @@ import random
 import tempfile
 from unittest.mock import patch
 
+from vllm.config import (DeviceConfig, LoRAConfig, ModelConfig, ParallelConfig,
+                         SchedulerConfig)
 from vllm.lora.models import LoRAMapping
 from vllm.lora.request import LoRARequest
-from vllm.config import (ModelConfig, ParallelConfig, SchedulerConfig,
-                         DeviceConfig, LoRAConfig)
 from vllm.worker.worker import Worker
 
 

tests/models/test_marlin.py

@@ -11,9 +11,11 @@ up to 3 times to see if we pass.
 Run `pytest tests/models/test_marlin.py --forked`.
 """
 
+from dataclasses import dataclass
+
 import pytest
 import torch
-from dataclasses import dataclass
+
 from vllm.model_executor.layers.quantization import (
     _QUANTIZATION_CONFIG_REGISTRY)
 

tests/samplers/test_logprobs.py

 import pytest
 import torch
-from tests.conftest import VllmRunner
 
+from tests.conftest import VllmRunner
 from vllm import SamplingParams
 
 MODELS = ["facebook/opt-125m"]

tests/samplers/test_rejection_sampler.py

 """Tests for rejection sampling."""
-import pytest
 from typing import List, Tuple
 
+import pytest
 import torch
 import torch.nn.functional as F
 
-from vllm.model_executor.utils import set_random_seed
-
 from vllm.model_executor.layers.rejection_sampler import RejectionSampler
+from vllm.model_executor.utils import set_random_seed
 
 CUDA_DEVICES = [
     f"cuda:{i}" for i in range(1 if torch.cuda.device_count() == 1 else 2)

tests/samplers/test_sampler.py

 import random
-from typing import Tuple, List
+from typing import List, Optional, Tuple
 from unittest.mock import patch
 
 import pytest
 import torch
 from transformers import GenerationConfig, GenerationMixin
-from typing import Optional
 
 from vllm.model_executor.layers.sampler import Sampler
 from vllm.model_executor.utils import set_random_seed

tests/samplers/test_seeded_generate.py

@@ -8,8 +8,8 @@ from itertools import combinations
 
 import pytest
 
-from vllm.model_executor.utils import set_random_seed
 from vllm import SamplingParams
+from vllm.model_executor.utils import set_random_seed
 
 MODEL = "facebook/opt-125m"
 RANDOM_SEEDS = list(range(5))

tests/spec_decode/test_batch_expansion.py

-import torch
 import pytest
+import torch
 
 from vllm.spec_decode.batch_expansion import BatchExpansionTop1Scorer
 
-from .utils import mock_worker, create_seq_group_metadata_from_prompts
+from .utils import create_seq_group_metadata_from_prompts, mock_worker
 
 
 @pytest.mark.parametrize('num_target_seq_ids', [100])

tests/spec_decode/test_metrics.py

-import torch
 import math
-import pytest
-
 from unittest.mock import MagicMock
 
+import pytest
+import torch
+
 from vllm.spec_decode.metrics import AsyncMetricsCollector
 
 

tests/spec_decode/test_multi_step_worker.py

-import torch
 import random
-import pytest
 from unittest.mock import MagicMock
 
-from vllm.spec_decode.multi_step_worker import (MultiStepWorker,
-                                                DraftModelTop1Proposer)
-from vllm.worker.worker import Worker
+import pytest
+import torch
+
 from vllm.model_executor.utils import set_random_seed
 from vllm.sequence import SamplerOutput
+from vllm.spec_decode.multi_step_worker import (DraftModelTop1Proposer,
+                                                MultiStepWorker)
+from vllm.worker.worker import Worker
 
-from .utils import (create_execute_model_data, create_worker,
-                    create_seq_group_metadata_from_prompts, zero_kv_cache,
-                    patch_execute_model_with_seeds,
-                    assert_logprobs_dict_allclose, create_batch)
+from .utils import (assert_logprobs_dict_allclose, create_batch,
+                    create_execute_model_data,
+                    create_seq_group_metadata_from_prompts, create_worker,
+                    patch_execute_model_with_seeds, zero_kv_cache)
 
 
 @pytest.mark.parametrize('num_steps', list(range(1, 17)))

tests/spec_decode/test_spec_decode_worker.py

-import torch
 import random
-import pytest
 from unittest.mock import MagicMock
 
+import pytest
+import torch
+
+from vllm.model_executor.layers.rejection_sampler import RejectionSampler
+from vllm.model_executor.utils import set_random_seed
+from vllm.spec_decode.interfaces import SpeculativeProposals
+from vllm.spec_decode.metrics import (AsyncMetricsCollector,
+                                      SpecDecodeWorkerMetrics)
 from vllm.spec_decode.multi_step_worker import MultiStepWorker
 from vllm.spec_decode.spec_decode_worker import (SpecDecodeWorker,
                                                  split_num_cache_blocks_evenly)
-from vllm.spec_decode.interfaces import SpeculativeProposals
-from vllm.model_executor.utils import set_random_seed
-from vllm.model_executor.layers.rejection_sampler import RejectionSampler
-from .utils import (mock_worker, create_batch, ExecuteModelData,
-                    create_sampler_output_list)
-from vllm.spec_decode.metrics import (SpecDecodeWorkerMetrics,
-                                      AsyncMetricsCollector)
+
+from .utils import (ExecuteModelData, create_batch, create_sampler_output_list,
+                    mock_worker)
 
 
 @pytest.mark.parametrize('k', [1, 2, 6])

tests/spec_decode/test_utils.py

-from vllm.spec_decode.util import get_all_seq_ids
-from vllm.sequence import SequenceGroupMetadata
-from vllm.spec_decode.util import split_batch_by_proposal_len
+from unittest.mock import MagicMock
 
 import pytest
-from unittest.mock import MagicMock
+
+from vllm.sequence import SequenceGroupMetadata
+from vllm.spec_decode.util import get_all_seq_ids, split_batch_by_proposal_len
 
 
 def test_get_all_seq_ids():

tests/spec_decode/utils.py

-import torch
-from typing import List, Optional, Dict, Iterable, Union
+from dataclasses import dataclass, fields
+from itertools import count
+from typing import Dict, Iterable, List, Optional, Union
 from unittest.mock import MagicMock
 
-from vllm.worker.worker import Worker
-from vllm.utils import get_distributed_init_method, get_ip, get_open_port
+import torch
+
 from vllm.engine.arg_utils import EngineArgs
-from vllm.sequence import (Logprob, SequenceGroupMetadata, SequenceData,
-                           SamplerOutput, SequenceGroupOutput, SequenceOutput)
+from vllm.model_executor.utils import set_random_seed
 from vllm.sampling_params import SamplingParams
+from vllm.sequence import (Logprob, SamplerOutput, SequenceData,
+                           SequenceGroupMetadata, SequenceGroupOutput,
+                           SequenceOutput)
+from vllm.utils import get_distributed_init_method, get_ip, get_open_port
 from vllm.worker.cache_engine import CacheEngine
-from vllm.model_executor.utils import set_random_seed
-from itertools import count
-from dataclasses import dataclass, fields
+from vllm.worker.worker import Worker
 
 
 @dataclass

tests/test_cache_block_hashing.py

@@ -7,8 +7,8 @@ from typing import List, Optional
 import pytest
 
 from vllm.lora.request import LoRARequest
-from vllm.transformers_utils.tokenizer_group import TokenizerGroup
 from vllm.sequence import Sequence
+from vllm.transformers_utils.tokenizer_group import TokenizerGroup
 
 # Make two prefixes with different first blocks.
 prefix_start = [("You are an expert"), ("You are a")]

tests/test_sequence.py

 import pytest
 
-from vllm.sequence import SequenceGroupOutput, SamplerOutput, SequenceOutput
+from vllm.sequence import SamplerOutput, SequenceGroupOutput, SequenceOutput
 
 
 @pytest.fixture

tests/tokenization/test_cached_tokenizer.py

 from copy import deepcopy
-from vllm.transformers_utils.tokenizer import get_cached_tokenizer
+
 from transformers import AutoTokenizer
 
+from vllm.transformers_utils.tokenizer import get_cached_tokenizer
+
 
 def test_cached_tokenizer():
     reference_tokenizer = AutoTokenizer.from_pretrained("gpt2")

tests/tokenization/test_detokenize.py

-import pytest
+from typing import Dict, List
 
+import pytest
 from transformers import AutoTokenizer
-from typing import List, Dict
 
-from vllm.sequence import Sequence, Logprob, SamplingParams, SequenceGroup
-from vllm.transformers_utils.tokenizer_group import get_tokenizer_group
-from vllm.transformers_utils.tokenizer import detokenize_incrementally
+from vllm.sequence import Logprob, SamplingParams, Sequence, SequenceGroup
 from vllm.transformers_utils.detokenizer import Detokenizer
+from vllm.transformers_utils.tokenizer import detokenize_incrementally
+from vllm.transformers_utils.tokenizer_group import get_tokenizer_group
 
 TRUTH = [
     "Hello here, this is a simple test",

tests/tokenization/test_tokenizer_group.py

-import os
-import pytest
 import asyncio
+import os
 from unittest.mock import patch
 
+import pytest
 from transformers import AutoTokenizer, PreTrainedTokenizerBase
+
 from vllm.transformers_utils.tokenizer_group import get_tokenizer_group
 from vllm.transformers_utils.tokenizer_group.ray_tokenizer_group import (
     RayTokenizerGroupPool)
 from vllm.transformers_utils.tokenizer_group.tokenizer_group import (
     TokenizerGroup)
+
 from ..conftest import get_tokenizer_pool_config
 
 

tests/worker/test_swap.py

 import torch
 
 from vllm.engine.arg_utils import EngineArgs
-from vllm.worker.worker import Worker
 from vllm.utils import get_distributed_init_method, get_ip, get_open_port
+from vllm.worker.worker import Worker
 
 
 def test_swap() -> None: