style + type fixes

Author: markVaykhansky

src/guidellm/backend/openai.py

@@ -93,7 +93,7 @@ def __init__(
             raise ValueError("Target URL must be provided for OpenAI HTTP backend.")
 
         if self._target.endswith("/v1") or self._target.endswith("/v1/"):
-            # backwards compatability, strip v1 off
+            # backwards compatibility, strip v1 off
             self._target = self._target[:-3]
 
         if self._target.endswith("/"):
@@ -572,12 +572,12 @@ async def _iterative_completions_request(
 
             async for line in stream.aiter_lines():
                 iter_time = time.time()
-                # logger.debug(
-                #     "{} request: {} recieved iter response line: {}",
-                #     self.__class__.__name__,
-                #     request_id,
-                #     line,
-                # )
+                logger.debug(
+                    "{} request: {} recieved iter response line: {}",
+                    self.__class__.__name__,
+                    request_id,
+                    line,
+                )
 
                 if not line or not line.strip().startswith("data:"):
                     continue

src/guidellm/objects/pydantic.py

@@ -1,10 +1,11 @@
 from typing import Any, Generic, TypeVar
 
-from loguru import logger
 from pydantic import BaseModel, ConfigDict, Field
 
 __all__ = ["StandardBaseModel", "StatusBreakdown"]
 
+from guidellm import logger
+
 
 class StandardBaseModel(BaseModel):
     """
@@ -21,11 +22,11 @@ class StandardBaseModel(BaseModel):
 
     def __init__(self, /, **data: Any) -> None:
         super().__init__(**data)
-        # logger.debug(
-        #     "Initialized new instance of {} with data: {}",
-        #     self.__class__.__name__,
-        #     data,
-        # )
+        logger.debug(
+            "Initialized new instance of {} with data: {}",
+            self.__class__.__name__,
+            data,
+        )
 
 
 SuccessfulT = TypeVar("SuccessfulT")

src/guidellm/scheduler/repro.py

@@ -50,6 +50,7 @@ class SchedulerRunInfo(StandardBaseModel):
     end_number: float
     processes: int
     strategy: SchedulingStrategy
+    last_requests_statuses: deque[RequestStatus]
     max_error_rate: Optional[float] = None
 
     created_requests: int = 0
@@ -59,8 +60,6 @@ class SchedulerRunInfo(StandardBaseModel):
     completed_requests: int = 0
     errored_requests: int = 0
 
-    last_requests_statuses: Optional[deque[RequestStatus]] = None
-
 
 class SchedulerRequestInfo(StandardBaseModel):
     """

src/guidellm/scheduler/result.py

@@ -1,6 +1,5 @@
-import collections
-from datetime import timedelta
 import asyncio
+import collections
 import math
 import multiprocessing
 import multiprocessing.queues
@@ -11,8 +10,10 @@
 from typing import (
     Any,
     Generic,
+    Literal,
     Optional,
-    Union, Literal, cast,
+    Union,
+    cast,
 )
 
 from loguru import logger
@@ -128,9 +129,7 @@ async def run(
                 requests_queue,
                 responses_queue,
                 shutdown_event,
-            ) = await self._start_processes(
-                manager, executor, scheduling_strategy
-            )
+            ) = await self._start_processes(manager, executor, scheduling_strategy)
             if shutdown_event.is_set():
                 raise RuntimeError("shutdown_event is set before starting scheduling")
 
@@ -156,7 +155,6 @@ async def run(
                     ):
                         # we've exhausted all requests we've wanted to run
                         # and yielded all responses
-                        logger.info("run_info.completed_requests >= run_info.created_requests")
                         break
 
                     requests_iter = self._add_requests(
@@ -229,10 +227,7 @@ def _is_max_error_rate_reached(self, run_info: SchedulerRunInfo) -> bool:
                 f"{max_error} (max error)"
             )
             return max_error < run_info.errored_requests
-        elif(
-            run_info.strategy.type_ == "constant"
-            and run_info.end_number != math.inf
-        ):
+        elif run_info.strategy.type_ == "constant" and run_info.end_number != math.inf:
             current_error_ratio = run_info.errored_requests / run_info.end_number
             logger.debug(
                 f"Current error rate {current_error_ratio} "
@@ -241,13 +236,12 @@ def _is_max_error_rate_reached(self, run_info: SchedulerRunInfo) -> bool:
             return max_error < current_error_ratio
         elif settings.error_check_window_size <= run_info.completed_requests:
             last_requests_statuses = run_info.last_requests_statuses
-            last_errored_requests_count = len([
-                s
-                for s
-                in last_requests_statuses
-                if s == "error"
-            ])
-            current_error_ratio = last_errored_requests_count / len(last_requests_statuses)
+            last_errored_requests_count = len(
+                [s for s in last_requests_statuses if s == "error"]
+            )
+            current_error_ratio = last_errored_requests_count / len(
+                last_requests_statuses
+            )
             logger.debug(
                 f"Current error rate in "
                 f"last requests window is "
@@ -353,7 +347,7 @@ def _run_setup(
             max_error_rate=max_error_rate,
             last_requests_statuses=collections.deque(
                 maxlen=settings.error_check_window_size
-            )
+            ),
         )
 
         return info, requests_iter, times_iter
@@ -471,8 +465,7 @@ def _check_result_ready(
                 run_info.errored_requests += 1
 
             request_status: Literal["error", "success"] = cast(
-                Literal["error", "success"],
-                "error" if is_errored else "success"
+                "Literal['error', 'success']", "error" if is_errored else "success"
             )
             run_info.last_requests_statuses.append(request_status)