Complete with Code quality configuration

Author: Dmytro Parfeniuk

Makefile

@@ -5,7 +5,7 @@ install:
 
 .PHONY: install.dev
 install.dev:
-	python -m pip install .[dev]
+	python -m pip install -e .[dev]
 
 
 .PHONY: build
@@ -63,3 +63,4 @@ clean:
 	find . -type d -name "__pycache__" -exec rm -r {} +
 	rm -rf .mypy_cache
 	rm -rf .pytest_cache
+	rm -rf .tox

README.md

@@ -18,3 +18,53 @@ set -o allexport; source .env; set +o allexport
 | --------------- | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | OPENAI_BASE_URL | http://127.0.0.1:8080 | The host where the `openai` library will make requests to. For running integration tests it is required to have the external OpenAI compatible server running. |
 | OPENAI_API_KEY  | invalid               | [OpenAI Platform](https://platform.openai.com/api-keys) to create a new API key. This value is not used for tests.                                             |
+
+</br>
+
+# Code Quality
+
+The variety of tools are available for checking the code quality.
+
+All the code quality tools configuration is placed into next files: `pyproject.toml`, `Makefile`, `tox.ini`
+
+**To provide the code quality next tools are used:**
+
+- `pytest` as a testing framework
+- `ruff` as a linter
+- `black` & `isort` as formatters
+- `mypy` as a static type checker
+- `tox` as a automation tool
+- `make` as a automation tool (works only on Unix by default)
+
+**Checking code quality using CLI**
+
+All the tools could be run right from the CLI.
+
+Recommended command template: `python -m pytest test.integration`
+
+
+**Checking code quality using Makefile**
+
+Using `Makefile` you can run almost all common scripts to check the code quality, install dependencies, and to provide auto fixes. All the commands from the `Makefile` are valid to be used in the CLI.
+
+Here are some commands
+
+```sh
+# install dev dependencies
+make install.dev
+
+# run unit tests
+make test.unit
+
+# run quality checkers
+make quality
+
+# run autofixes
+make style
+```
+
+**Checking code quality using tox**
+
+The `tox` is an automation tool for running code quality checkers for selected Python versions. The configuration is placed in the `tox.ini`.
+
+To run the automation just run: `python -m tox`

docs/conf.py

@@ -1 +1 @@
-TODO
+TODO

pyproject.toml

@@ -36,21 +36,19 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "black",
-    "isort",
-    "mypy",
+    "guidellm[code_quality]",
     "pre-commit",
-    "pytest",
-    "ruff",
     "sphinx",
-    "tox",
 ]
 code_quality = [
     "black",
     "isort",
     "mypy",
     "pytest",
+    "pytest-mock",
     "ruff",
+    "tox",
+    "types-requests"
 ]
 
 
@@ -84,6 +82,10 @@ exclude = ["venv", ".tox"]
 # Check: https://mypy.readthedocs.io/en/latest/config_file.html#import-discovery
 follow_imports = 'silent'
 
+[[tool.mypy.overrides]]
+module = ["transformers.*", "datasets.*"]
+ignore_missing_imports=true
+
 
 [tool.ruff]
 line-length = 88

src/guidellm/backend/base.py

@@ -102,7 +102,6 @@ def submit(self, request: TextGenerationRequest) -> TextGenerationResult:
                 result.output_token(response.add_token)
             elif response.type_ == "final":
                 result.end(
-                    response.output or "",
                     response.prompt_token_count,
                     response.output_token_count,
                 )

src/guidellm/core/result.py

@@ -148,9 +148,7 @@ def end_time(self) -> float:
         :rtype: float
         """
 
-        self._recording_started()
         assert self._end_time
-
         return self._end_time
 
     @property
@@ -173,6 +171,11 @@ def decode_times(self) -> Distribution:
         """
         return self._decode_times
 
+    @property
+    def last_time(self) -> float:
+        assert self._last_time
+        return self._last_time
+
     def start(self, prompt: str):
         """
         Start the text generation by recording the prompt and start time.
@@ -193,16 +196,16 @@ def _recording_started(self, raise_exception: bool = True) -> bool:
         """
         Ensure that the benchmark text generation recording is started.
 
-        We can assume that if the `self.start_time` & `self.end_time` exist
+        We can assume that if the `self._start_time` exist,
         then the `start()` has been called.
         """
 
-        if (self.start_time is not None) and (self.end_time is not None):
+        if self._start_time is not None:
             return True
         else:
             if raise_exception is True:
                 raise ValueError(
-                    "Last time is not specified. "
+                    "start time is not specified. "
                     "Did you make the `text_generation_benchmark.start()`?"
                 )
             else:
@@ -219,11 +222,11 @@ def output_token(self, token: str):
         current_counter = perf_counter()
 
         if not self._first_token_set:
-            self._first_token_time = current_counter - self.end_time
+            self._first_token_time = current_counter - self.last_time
             self._first_token_set = True
             logger.debug(f"First token decode time: {self._first_token_time}")
         else:
-            decode_time = current_counter - self.end_time
+            decode_time = current_counter - self.last_time
             self._decode_times.add_data([decode_time])
             logger.debug(f"Token '{token}' decoded in {decode_time} seconds")
 
@@ -232,7 +235,6 @@ def output_token(self, token: str):
 
     def end(
         self,
-        output: str,
         prompt_token_count: Optional[int] = None,
         output_token_count: Optional[int] = None,
     ):
@@ -254,7 +256,7 @@ def end(
         self._output_token_count = output_token_count or self._output_word_count
         self._prompt_token_count = prompt_token_count or self._prompt_word_count
 
-        logger.info(f"Text generation ended with output: '{output}'")
+        logger.info(f"Text generation ended with output: '{self.output}'")
 
 
 class TextGenerationError:

src/guidellm/main.py

@@ -96,7 +96,9 @@ def main(
         )
 
     if data_type == "emulated":
-        request_generator: RequestGenerator = EmulatedRequestGenerator(config=data, tokenizer=tokenizer)
+        request_generator: RequestGenerator = EmulatedRequestGenerator(
+            config=data, tokenizer=tokenizer
+        )
     elif data_type == "file":
         request_generator = FileRequestGenerator(file_path=data, tokenizer=tokenizer)
     elif data_type == "transformers":

src/guidellm/request/emulated.py

@@ -141,10 +141,10 @@ def _load_emulated_data(self) -> List[str]:
             .replace("! ", "!\n")
             .replace("? ", "?\n")
         )
-        lines = lines.split("\n")
-        lines = [line.strip() for line in lines if line and line.strip()]
+        _lines: List[str] = lines.split("\n")
+        _lines = [line.strip() for line in lines if line and line.strip()]
 
-        return lines
+        return _lines
 
     def _token_count(self, text: str) -> int:
         return (

src/guidellm/scheduler/scheduler.py

@@ -1,6 +1,6 @@
 import asyncio
 import time
-from typing import Iterable, Optional, Union
+from typing import Iterable, List, Optional, Union
 
 from guidellm.backend import Backend
 from guidellm.core import TextGenerationBenchmark, TextGenerationError
@@ -71,22 +71,23 @@ async def _run_async(self) -> TextGenerationBenchmark:
         result_set = TextGenerationBenchmark(
             mode=self._load_gen_mode.value, rate=self._load_gen_rate
         )
-        if (not self._load_gen_rate):
+        if not self._load_gen_rate:
             raise ValueError("Invalid empty value for self._load_gen_rate")
         load_gen = LoadGenerator(self._load_gen_mode, self._load_gen_rate)
 
-        tasks = []
+        tasks: List[asyncio.tasks.Task] = []
         start_time = time.time()
         counter = 0
+
         try:
-            for task, task_start_time in zip(self._task_iterator(), load_gen.times()):
+            for _task, task_start_time in zip(self._task_iterator(), load_gen.times()):
                 pending_time = task_start_time - time.time()
 
                 if pending_time > 0:
                     await asyncio.sleep(pending_time)
 
                 tasks.append(
-                    asyncio.create_task(self._run_task_async(task, result_set))
+                    asyncio.create_task(self._run_task_async(_task, result_set))
                 )
                 counter += 1
 
@@ -106,7 +107,7 @@ async def _run_async(self) -> TextGenerationBenchmark:
 
             await asyncio.gather(*tasks)
         except asyncio.CancelledError:
-            # Cancel all pending tasks
+            # Cancel all pending asyncio.Tasks instances
             for task in tasks:
                 if not task.done():
                     task.cancel()

src/guidellm/scheduler/task.py

@@ -1,4 +1,5 @@
 import asyncio
+import functools
 from typing import Any, Callable, Dict, Optional
 
 from loguru import logger
@@ -25,10 +26,11 @@ def __init__(
         params: Optional[Dict[str, Any]] = None,
         err_container: Optional[Callable] = None,
     ):
-        self._func = func
-        self._params = params or {}
-        self._err_container = err_container
-        self._cancel_event = asyncio.Event()
+        self._func: Callable[..., Any] = func
+        self._params: Dict[str, Any] = params or {}
+        self._err_container: Optional[Callable] = err_container
+        self._cancel_event: asyncio.Event = asyncio.Event()
+
         logger.info(
             f"Task created with function: {self._func.__name__} and "
             f"params: {self._params}"
@@ -43,15 +45,19 @@ async def run_async(self) -> Any:
         """
         logger.info(f"Running task asynchronously with function: {self._func.__name__}")
         try:
+            loop = asyncio.get_running_loop()
+
             result = await asyncio.gather(
-                asyncio.to_thread(self._func, **self._params),
+                loop.run_in_executor(
+                    None, functools.partial(self._func, **self._params)
+                ),
                 self._check_cancelled(),
                 return_exceptions=True,
             )
             if isinstance(result[0], Exception):
                 raise result[0]
 
-            if self.is_cancelled():
+            if self.cancelled is True:
                 raise asyncio.CancelledError("Task was cancelled")
 
             logger.info(f"Task completed with result: {result[0]}")
@@ -92,7 +98,7 @@ def run_sync(self) -> Any:
                 else self._err_container(**self._params, error=err)
             )
 
-    def cancel(self):
+    def cancel(self) -> None:
         """
         Cancel the task.
         """
@@ -105,7 +111,8 @@ async def _check_cancelled(self):
         """
         await self._cancel_event.wait()
 
-    def is_cancelled(self) -> bool:
+    @property
+    def cancelled(self) -> bool:
         """
         Check if the task is cancelled.