run make style

Author: DaltheCow

src/guidellm/executor/__init__.py

@@ -1,12 +1,12 @@
 from .executor import Executor
 from .profile_generator import (
-    rate_type_to_load_gen_mode,
-    rate_type_to_profile_mode,
+    FixedRateProfileGenerator,
     Profile,
     ProfileGenerationMode,
     ProfileGenerator,
-    FixedRateProfileGenerator,
     SweepProfileGenerator,
+    rate_type_to_load_gen_mode,
+    rate_type_to_profile_mode,
 )
 
 __all__ = [

src/guidellm/executor/profile_generator.py

@@ -19,21 +19,23 @@
 rate_type_to_load_gen_mode = {
     "synchronous": LoadGenerationMode.SYNCHRONOUS,
     "constant": LoadGenerationMode.CONSTANT,
-    "poisson": LoadGenerationMode.POISSON
+    "poisson": LoadGenerationMode.POISSON,
 }
 
 
 class ProfileGenerationMode(Enum):
     FIXED_RATE = "fixed_rate"
     SWEEP = "sweep"
 
+
 rate_type_to_profile_mode = {
     "synchronous": ProfileGenerationMode.FIXED_RATE,
     "constant": ProfileGenerationMode.FIXED_RATE,
     "poisson": ProfileGenerationMode.FIXED_RATE,
     "sweep": ProfileGenerationMode.SWEEP,
 }
 
+
 @dataclass
 class Profile:
     load_gen_mode: LoadGenerationMode
@@ -69,7 +71,12 @@ def next(self, current_report: TextGenerationBenchmarkReport) -> Optional[Profil
 
 @ProfileGenerator.register(ProfileGenerationMode.FIXED_RATE)
 class FixedRateProfileGenerator(ProfileGenerator):
-    def __init__(self, load_gen_mode: Optional[LoadGenerationMode], rates: Optional[List[float]] = None, **kwargs):
+    def __init__(
+        self,
+        load_gen_mode: Optional[LoadGenerationMode],
+        rates: Optional[List[float]] = None,
+        **kwargs,
+    ):
         super().__init__(ProfileGenerationMode.FIXED_RATE)
         if load_gen_mode == "synchronous" and rates and len(rates) > 0:
             raise ValueError("custom rates are not supported in synchronous mode")
@@ -78,17 +85,18 @@ def __init__(self, load_gen_mode: Optional[LoadGenerationMode], rates: Optional[
         self._generated: bool = False
         self._rate_index: int = 0
 
-    def next(
-        self, current_report: TextGenerationBenchmarkReport
-    ) -> Optional[Profile]:
+    def next(self, current_report: TextGenerationBenchmarkReport) -> Optional[Profile]:
         if self._load_gen_mode.name == LoadGenerationMode.SYNCHRONOUS.name:
             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.name in {
+            LoadGenerationMode.CONSTANT.name,
+            LoadGenerationMode.POISSON.name,
+        }:
             if self._rate_index >= len(self._rates):
                 return None
             current_rate = self._rates[self._rate_index]
@@ -154,4 +162,4 @@ def next(self, current_report: TextGenerationBenchmarkReport) -> Optional[Profil
                 load_gen_mode=LoadGenerationMode.CONSTANT, load_gen_rate=rate
             )
 
-        return None
+        return None

src/guidellm/main.py

@@ -2,7 +2,11 @@
 
 from guidellm.backend import Backend
 from guidellm.core import TextGenerationBenchmarkReport
-from guidellm.executor import Executor, rate_type_to_load_gen_mode, rate_type_to_profile_mode
+from guidellm.executor import (
+    Executor,
+    rate_type_to_load_gen_mode,
+    rate_type_to_profile_mode,
+)
 from guidellm.request import (
     EmulatedRequestGenerator,
     FileRequestGenerator,
@@ -107,10 +111,10 @@ def main(
         )
     else:
         raise ValueError(f"Unknown data type: {data_type}")
-    
+
     profile_mode = rate_type_to_profile_mode(rate_type)
     load_gen_mode = rate_type_to_load_gen_mode.get(rate_type, None)
-    
+
     # Create executor
     executor = Executor(
         request_generator=request_generator,

tests/unit/executor/test_executor.py

@@ -1,20 +1,29 @@
-import pytest
 from unittest.mock import MagicMock, patch
+
+import pytest
+
 from guidellm.backend.base import Backend
-from guidellm.executor import Executor
-from guidellm.executor import Profile, ProfileGenerator
+from guidellm.executor import Executor, Profile, ProfileGenerator
 from guidellm.executor.profile_generator import ProfileGenerationMode
 from guidellm.request.base import RequestGenerator
 from guidellm.scheduler import LoadGenerationMode
 
+
 def test_executor_creation():
     mock_request_generator = MagicMock(spec=RequestGenerator)
     mock_backend = MagicMock(spec=Backend)
     profile_mode = ProfileGenerationMode.SWEEP
     profile_args = None
-    max_requests = None,
-    max_duration = None,
-    executor = Executor(mock_backend, mock_request_generator, profile_mode, profile_args, max_requests, max_duration);
+    max_requests = (None,)
+    max_duration = (None,)
+    executor = Executor(
+        mock_backend,
+        mock_request_generator,
+        profile_mode,
+        profile_args,
+        max_requests,
+        max_duration,
+    )
     assert executor.request_generator == mock_request_generator
     assert executor.backend == mock_backend
     assert executor.max_requests == max_requests
@@ -25,47 +34,54 @@ def test_executor_creation():
 def mock_request_generator():
     return MagicMock(spec=RequestGenerator)
 
+
 @pytest.fixture
 def mock_backend():
     return MagicMock(spec=Backend)
 
+
 @pytest.fixture
 def mock_scheduler():
-    with patch('guidellm.executor.executor.Scheduler') as MockScheduler:
+    with patch("guidellm.executor.executor.Scheduler") as MockScheduler:
         yield MockScheduler
 
-def test_executor_run(mock_request_generator, mock_backend, mock_scheduler):
 
+def test_executor_run(mock_request_generator, mock_backend, mock_scheduler):
     mock_profile_generator = MagicMock(spec=ProfileGenerator)
     profiles = [
         Profile(load_gen_mode=LoadGenerationMode.CONSTANT, load_gen_rate=1.0),
         Profile(load_gen_mode=LoadGenerationMode.CONSTANT, load_gen_rate=2.0),
-        None
+        None,
     ]
     mock_profile_generator.next.side_effect = profiles
-    
-    with patch('guidellm.executor.executor.ProfileGenerator.create', return_value=mock_profile_generator):
+
+    with patch(
+        "guidellm.executor.executor.ProfileGenerator.create",
+        return_value=mock_profile_generator,
+    ):
         executor = Executor(
             request_generator=mock_request_generator,
             backend=mock_backend,
             profile_mode=ProfileGenerationMode.FIXED_RATE,
-            profile_args={"load_gen_mode": LoadGenerationMode.CONSTANT, "rates": [1.0, 2.0]},
+            profile_args={
+                "load_gen_mode": LoadGenerationMode.CONSTANT,
+                "rates": [1.0, 2.0],
+            },
             max_requests=10,
-            max_duration=100
+            max_duration=100,
         )
 
         mock_benchmark = MagicMock()
         mock_scheduler.return_value.run.return_value = mock_benchmark
 
         report = executor.run()
 
-
         assert mock_scheduler.call_count == 2
         assert len(report.benchmarks) == 2
         assert report.benchmarks[0] == mock_benchmark
         assert report.benchmarks[1] == mock_benchmark
         calls = mock_scheduler.call_args_list
-        assert calls[0][1]['load_gen_mode'] == LoadGenerationMode.CONSTANT
-        assert calls[0][1]['load_gen_rate'] == 1.0
-        assert calls[1][1]['load_gen_mode'] == LoadGenerationMode.CONSTANT
-        assert calls[1][1]['load_gen_rate'] == 2.0
+        assert calls[0][1]["load_gen_mode"] == LoadGenerationMode.CONSTANT
+        assert calls[0][1]["load_gen_rate"] == 1.0
+        assert calls[1][1]["load_gen_mode"] == LoadGenerationMode.CONSTANT
+        assert calls[1][1]["load_gen_rate"] == 2.0