fix linting issues

Author: DaltheCow

src/guidellm/executor/profile_generator.py

@@ -78,32 +78,33 @@ def __init__(
         **kwargs,
     ):
         super().__init__(ProfileGenerationMode.FIXED_RATE)
-        if load_gen_mode == "synchronous" and rates and len(rates) > 0:
+        if load_gen_mode == LoadGenerationMode.SYNCHRONOUS and rates and len(rates) > 0:
             raise ValueError("custom rates are not supported in synchronous mode")
         self._rates: Optional[List[float]] = rates
-        self._load_gen_mode: LoadGenerationMode = load_gen_mode
+        self._load_gen_mode = load_gen_mode
         self._generated: bool = False
         self._rate_index: int = 0
 
     def next(self, current_report: TextGenerationBenchmarkReport) -> Optional[Profile]:
-        if self._load_gen_mode.name == LoadGenerationMode.SYNCHRONOUS.name:
+        if self._load_gen_mode == LoadGenerationMode.SYNCHRONOUS:
             if self._generated:
                 return None
             self._generated = True
             return Profile(
                 load_gen_mode=LoadGenerationMode.SYNCHRONOUS, load_gen_rate=None
             )
-        elif self._load_gen_mode.name in {
-            LoadGenerationMode.CONSTANT.name,
-            LoadGenerationMode.POISSON.name,
+        elif self._load_gen_mode in {
+            LoadGenerationMode.CONSTANT,
+            LoadGenerationMode.POISSON,
         }:
-            if self._rate_index >= len(self._rates):
-                return None
-            current_rate = self._rates[self._rate_index]
-            self._rate_index += 1
-            return Profile(
-                load_gen_mode=self._load_gen_mode, load_gen_rate=current_rate
-            )
+            if self._rates:
+                if self._rate_index >= len(self._rates):
+                    return None
+                current_rate = self._rates[self._rate_index]
+                self._rate_index += 1
+                return Profile(
+                    load_gen_mode=self._load_gen_mode, load_gen_rate=current_rate
+                )
 
         raise ValueError(f"Invalid rate type: {self._load_gen_mode}")
 

src/guidellm/main.py

@@ -13,7 +13,6 @@
     TransformersDatasetRequestGenerator,
 )
 from guidellm.request.base import RequestGenerator
-from guidellm.scheduler.load_generator import LoadGenerationMode
 
 
 @click.command()
@@ -112,9 +111,10 @@ def main(
     else:
         raise ValueError(f"Unknown data type: {data_type}")
 
-    profile_mode = rate_type_to_profile_mode(rate_type)
+    profile_mode = rate_type_to_profile_mode.get(rate_type)
     load_gen_mode = rate_type_to_load_gen_mode.get(rate_type, None)
-
+    if not profile_mode or not load_gen_mode:
+        raise ValueError("Invalid rate type")
     # Create executor
     executor = Executor(
         request_generator=request_generator,

tests/unit/executor/test_executor.py

@@ -14,8 +14,8 @@ def test_executor_creation():
     mock_backend = MagicMock(spec=Backend)
     profile_mode = ProfileGenerationMode.SWEEP
     profile_args = None
-    max_requests = (None,)
-    max_duration = (None,)
+    max_requests = None
+    max_duration = None
     executor = Executor(
         mock_backend,
         mock_request_generator,

tests/unit/executor/test_single_profile_generation_mode.py renamed to tests/unit/executor/test_fixed_rate_profile_generation_mode.py

@@ -1,3 +1,5 @@
+from typing import List, Optional
+
 import pytest
 
 from guidellm.core import TextGenerationBenchmark, TextGenerationBenchmarkReport
@@ -24,7 +26,7 @@ def test_executor_single_profile_generator_benchmark_report(
     request_genrator = dummy.services.TestRequestGenerator(
         tokenizer="bert-base-uncased"
     )
-    rates = [1.0]
+    rates: Optional[List[float]] = [1.0]
     if load_gen_mode == LoadGenerationMode.SYNCHRONOUS:
         rates = None
     profile_generator_kwargs = {"load_gen_mode": load_gen_mode, "rates": rates}

tests/unit/executor/test_profile_generator.py

@@ -1,3 +1,4 @@
+from profile import Profile
 from unittest.mock import MagicMock
 
 import numpy
@@ -9,28 +10,27 @@
     ProfileGenerationMode,
     ProfileGenerator,
     SweepProfileGenerator,
-    profile_generator,
 )
 from guidellm.scheduler import LoadGenerationMode
 
 # Fixed Rate Profile Generator
 
 
 def test_fixed_rate_profile_generator_creation():
-    rates = [1]
+    rates = [1.0]
     load_gen_mode = LoadGenerationMode.CONSTANT
-    profile_generator = ProfileGenerator.create(
+    test_profile_generator = ProfileGenerator.create(
         ProfileGenerationMode.FIXED_RATE,
         **({"rates": rates, "load_gen_mode": load_gen_mode}),
     )
-    assert isinstance(profile_generator, FixedRateProfileGenerator)
-    assert profile_generator._rates == rates
-    assert profile_generator._load_gen_mode.name == load_gen_mode.name
-    assert profile_generator._rate_index == 0
+    assert isinstance(test_profile_generator, FixedRateProfileGenerator)
+    assert test_profile_generator._rates == rates
+    assert test_profile_generator._load_gen_mode == load_gen_mode
+    assert test_profile_generator._rate_index == 0
 
 
 def test_synchronous_mode_rate_list_error():
-    rates = [1]
+    rates = [1.0]
     load_gen_mode = LoadGenerationMode.SYNCHRONOUS
     with pytest.raises(
         ValueError, match="custom rates are not supported in synchronous mode"
@@ -42,69 +42,75 @@ def test_synchronous_mode_rate_list_error():
 
 
 def test_next_with_multiple_rates():
-    rates = [1, 2]
+    rates = [1.0, 2.0]
     load_gen_mode = LoadGenerationMode.CONSTANT
-    profile_generator = ProfileGenerator.create(
+    test_profile_generator = ProfileGenerator.create(
         ProfileGenerationMode.FIXED_RATE,
         **({"rates": rates, "load_gen_mode": load_gen_mode}),
     )
     mock_report = MagicMock(spec=TextGenerationBenchmarkReport)
-    for rates in rates:
-        current_profile = profile_generator.next(mock_report)
-        assert current_profile.load_gen_rate == rates
-        assert current_profile.load_gen_mode.name == LoadGenerationMode.CONSTANT.name
-    assert profile_generator.next(mock_report) == None
+    for rate in rates:
+        current_profile = test_profile_generator.next(mock_report)
+        assert current_profile is not None
+        assert current_profile.load_gen_rate == rate
+        assert current_profile.load_gen_mode == LoadGenerationMode.CONSTANT
+    assert test_profile_generator.next(mock_report) is None
 
 
 def test_next_with_sync_mode():
     load_gen_mode = LoadGenerationMode.SYNCHRONOUS
-    profile_generator = ProfileGenerator.create(
+    test_profile_generator = ProfileGenerator.create(
         ProfileGenerationMode.FIXED_RATE, **({"load_gen_mode": load_gen_mode})
     )
     mock_report = MagicMock(spec=TextGenerationBenchmarkReport)
-    current_profile = profile_generator.next(mock_report)
-    assert current_profile.load_gen_rate == None
-    assert current_profile.load_gen_mode.name == LoadGenerationMode.SYNCHRONOUS.name
-    assert profile_generator.next(mock_report) == None
+    current_profile = test_profile_generator.next(mock_report)
+    assert current_profile is not None
+    assert current_profile.load_gen_rate is None
+    assert current_profile.load_gen_mode == LoadGenerationMode.SYNCHRONOUS
+    assert test_profile_generator.next(mock_report) is None
 
 
 # Sweep Profile Generator
 
 
 def test_sweep_profile_generator_creation():
-    profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP, **({}))
-    assert isinstance(profile_generator, SweepProfileGenerator)
-    assert profile_generator._sync_run == False
-    assert profile_generator._max_found == False
-    assert profile_generator._pending_rates == None
-    assert profile_generator._pending_rates == None
+    test_profile_generator = ProfileGenerator.create(
+        ProfileGenerationMode.SWEEP, **({})
+    )
+    assert isinstance(test_profile_generator, SweepProfileGenerator)
+    assert not test_profile_generator._sync_run
+    assert not test_profile_generator._max_found
+    assert test_profile_generator._pending_rates is None
+    assert test_profile_generator._pending_rates is None
 
 
 def test_first_profile_is_synchronous():
-    profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
+    test_profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
     mock_report = MagicMock(spec=TextGenerationBenchmarkReport)
-    profile = profile_generator.next(mock_report)
-    assert profile.load_gen_rate == None
-    assert profile.load_gen_mode.name == LoadGenerationMode.SYNCHRONOUS.name
+    profile = test_profile_generator.next(mock_report)
+    assert profile is not None
+    assert profile.load_gen_rate is None
+    assert profile.load_gen_mode == LoadGenerationMode.SYNCHRONOUS
 
 
 def test_rate_doubles():
-    profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
+    test_profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
     mock_report = MagicMock(spec=TextGenerationBenchmarkReport)
     mock_benchmark = MagicMock(spec=TextGenerationBenchmark)
     mock_benchmark.overloaded = False
     mock_benchmark.rate = 2.0
     mock_benchmark.request_rate = 2.0
     benchmarks = [mock_benchmark]
     mock_report.benchmarks = benchmarks
-    profile = profile_generator.next(mock_report)
+    test_profile_generator.next(mock_report)
 
-    profile = profile_generator.next(mock_report)
+    profile = test_profile_generator.next(mock_report)
+    assert profile is not None
     assert profile.load_gen_rate == 4.0
 
 
 def test_max_found():
-    profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
+    test_profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
     mock_report = MagicMock(spec=TextGenerationBenchmarkReport)
     mock_benchmark = MagicMock(spec=TextGenerationBenchmark)
     mock_benchmark.overloaded = False
@@ -117,15 +123,16 @@ def test_max_found():
     benchmarks = [mock_benchmark, mock_overloaded_benchmark]
     mock_report.benchmarks = benchmarks
 
-    profile_generator.next(mock_report)
-    profile = profile_generator.next(mock_report)
+    test_profile_generator.next(mock_report)
+    profile = test_profile_generator.next(mock_report)
+    assert profile is not None
 
     # if benchmark wasn't overloaded, rates would have doubled to 8
     assert profile.load_gen_rate == 2.0
 
 
 def test_pending_rates():
-    profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
+    test_profile_generator = ProfileGenerator.create(ProfileGenerationMode.SWEEP)
     mock_report = MagicMock(spec=TextGenerationBenchmarkReport)
     mock_benchmark = MagicMock(spec=TextGenerationBenchmark)
     mock_benchmark.overloaded = False
@@ -137,7 +144,8 @@ def test_pending_rates():
     mock_overloaded_benchmark.request_rate = 8.0
     benchmarks = [mock_benchmark, mock_overloaded_benchmark]
     mock_report.benchmarks = benchmarks
-    profile = profile_generator.next(mock_report)
+    profile = test_profile_generator.next(mock_report)
+    assert profile is not None
     for expected_rate in numpy.linspace(2.0, 8.0, 10):
-        profile = profile_generator.next(mock_report)
+        profile = test_profile_generator.next(mock_report)
         assert profile.load_gen_rate == expected_rate