guidellm 0.4.0a155__py3-none-any.whl → 0.4.0a173__py3-none-any.whl

guidellm/data/preprocessors/preprocessor.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from typing import Any, Protocol, Union, runtime_checkable
+from typing import Any, Protocol, runtime_checkable
 
 from datasets import Dataset, IterableDataset
 
+from guidellm.schemas import GenerationRequest
 from guidellm.utils import RegistryMixin
 
 __all__ = ["DataDependentPreprocessor", "DatasetPreprocessor", "PreprocessorRegistry"]
@@ -11,7 +12,8 @@ __all__ = ["DataDependentPreprocessor", "DatasetPreprocessor", "PreprocessorRegi
 
 @runtime_checkable
 class DatasetPreprocessor(Protocol):
-    def __call__(self, item: dict[str, Any]) -> dict[str, Any]: ...
+    def __call__(self, item: dict[str, Any]) -> (
+        GenerationRequest | dict[str, Any]): ...
 
 
 @runtime_checkable
@@ -24,6 +26,6 @@ class DataDependentPreprocessor(DatasetPreprocessor, Protocol):
 
 
 class PreprocessorRegistry(
-    RegistryMixin[Union[DataDependentPreprocessor, type[DataDependentPreprocessor]]]
+    RegistryMixin[DataDependentPreprocessor | type[DataDependentPreprocessor]]
 ):
     pass

guidellm/data/processor.py

@@ -23,8 +23,9 @@ class ProcessorFactory:
         if isinstance(self.processor, PreTrainedTokenizerBase):
             return self.processor
         else:
-            self.processor = AutoTokenizer.from_pretrained(
+            from_pretrained = AutoTokenizer.from_pretrained(
                 self.processor,
                 **(self.processor_args or {}),
             )
-            return self.processor
+            self.processor = from_pretrained
+            return from_pretrained

guidellm/data/utils/__init__.py

@@ -1,10 +1,6 @@
 from .dataset import DEFAULT_SPLITS, resolve_dataset_split
-from .functions import (
-    text_stats,
-)
 
 __all__ = [
     "DEFAULT_SPLITS",
     "resolve_dataset_split",
-    "text_stats",
 ]

guidellm/data/utils/dataset.py

@@ -73,7 +73,7 @@ def resolve_dataset_split(
     dataset: Dataset | IterableDataset | DatasetDict | IterableDatasetDict,
     split: str | None = None,
 ) -> Dataset | IterableDataset:
-    if split is not None and isinstance(dataset, (DatasetDict, IterableDatasetDict)):
+    if split is not None and isinstance(dataset, DatasetDict | IterableDatasetDict):
         if split in dataset:
             return dataset[split]
 
@@ -83,7 +83,7 @@ def resolve_dataset_split(
             f"Requested split '{split}' but dataset has no splits: {dataset}."
         )
 
-    if isinstance(dataset, (Dataset, IterableDataset)):
+    if isinstance(dataset, Dataset | IterableDataset):
         return dataset
 
     for _, default_splits in DEFAULT_SPLITS.items():

guidellm/scheduler/constraints.py

@@ -1005,9 +1005,7 @@ class RequestsExhaustedConstraint(StandardBaseModel, InfoMixin):
         return self.model_dump()
 
     def __call__(
-        self,
-        state: SchedulerState,
-        request_info: RequestInfo,  # noqa: ARG002
+        self, state: SchedulerState, _request: RequestInfo
     ) -> SchedulerUpdateAction:
         create_exceeded = state.created_requests >= self.num_requests
         processed_exceeded = state.processed_requests >= self.num_requests

guidellm/scheduler/environments.py

@@ -84,7 +84,7 @@ class Environment(ABC, Generic[RequestT, ResponseT], InfoMixin):
     async def update_run_iteration(
         self,
         response: ResponseT | None,
-        request: RequestT,
+        request: RequestT | MultiTurnRequestT[RequestT],
         request_info: RequestInfo,
         state: SchedulerState,
     ):
@@ -201,7 +201,7 @@ class NonDistributedEnvironment(Environment[RequestT, ResponseT]):
     async def update_run_iteration(
         self,
         response: ResponseT | None,
-        request: RequestT,
+        request: RequestT | MultiTurnRequestT[RequestT],
         request_info: RequestInfo,
         state: SchedulerState,
     ):

guidellm/scheduler/scheduler.py

@@ -69,7 +69,7 @@ class Scheduler(
     ) -> AsyncIterator[
         tuple[
             ResponseT | None,
-            RequestT,
+            RequestT | MultiTurnRequestT[RequestT],
             RequestInfo,
             SchedulerState,
         ]

guidellm/scheduler/strategies.py

@@ -70,8 +70,8 @@ class SchedulingStrategy(PydanticClassRegistryMixin["SchedulingStrategy"], InfoM
         description="Number of worker processes to use for this strategy",
         ge=0,
     )
-    max_concurrency: int = Field(
-        default=0,
+    max_concurrency: int | None = Field(
+        default=None,
         description="Maximum number of concurrent requests to allow",
         ge=0,
     )
@@ -122,8 +122,8 @@ class SchedulingStrategy(PydanticClassRegistryMixin["SchedulingStrategy"], InfoM
         self.startup_duration = startup_duration
 
         self._processes_request_index = Value("i", 0)
-        self._processes_lock = Lock()
         self._processes_start_time = Value("d", -1.0)
+        self._processes_lock = Lock()
 
     def init_processes_start(self, start_time: float):
         """
@@ -137,6 +137,10 @@ class SchedulingStrategy(PydanticClassRegistryMixin["SchedulingStrategy"], InfoM
                 "SchedulingStrategy init_processes_start called before "
                 "init_processes_timings"
             )
+        if self._processes_start_time is None:
+            raise RuntimeError(
+                "_processes_lock is not None but _processes_start_time is None"
+            )
 
         with self._processes_lock:
             self._processes_start_time.value = start_time
@@ -153,6 +157,10 @@ class SchedulingStrategy(PydanticClassRegistryMixin["SchedulingStrategy"], InfoM
                 "SchedulingStrategy get_processes_start_time called before "
                 "init_processes_timings"
             )
+        if self._processes_start_time is None:
+            raise RuntimeError(
+                "_processes_lock is not None but _processes_start_time is None"
+            )
 
         while self._cached_processes_start_time is None:
             with self._processes_lock:
@@ -175,6 +183,10 @@ class SchedulingStrategy(PydanticClassRegistryMixin["SchedulingStrategy"], InfoM
                 "SchedulingStrategy next_request_index called before "
                 "init_processes_timings"
             )
+        if self._processes_request_index is None:
+            raise RuntimeError(
+                "_processes_lock is not None but _processes_request_index is None"
+            )
 
         with self._processes_lock:
             self._processes_request_index.value += 1
@@ -369,7 +381,8 @@ class ThroughputStrategy(SchedulingStrategy):
         start_time = await self.get_processes_start_time()
 
         if (
-            self.startup_duration > 0
+            self.max_concurrency is not None
+            and self.startup_duration > 0
             and (time.time() - start_time) < self.startup_duration
             and (current_index := self.next_request_index()) <= self.max_concurrency
         ):
@@ -477,6 +490,8 @@ class AsyncPoissonStrategy(ThroughputStrategy):
         :param startup_duration: Duration in seconds for request startup ramping
         """
         super().init_processes_timings(worker_count, max_concurrency, startup_duration)
+        if self._processes_lock is None:
+            raise RuntimeError("_processes_lock is None in init_processes_timings")
         with self._processes_lock:
             self._offset = Value("d", -1.0)
 
@@ -487,6 +502,12 @@ class AsyncPoissonStrategy(ThroughputStrategy):
         :param start_time: Unix timestamp when request processing should begin
         """
         ThroughputStrategy.init_processes_start(self, start_time)
+
+        if self._processes_lock is None:
+            raise RuntimeError("_processes_lock is None in init_processes_start")
+        if self._offset is None:
+            raise RuntimeError("_offset is None in init_processes_start; was "
+                               "init_processes_timings not called?")
         with self._processes_lock:
             self._offset.value = start_time
 
@@ -505,6 +526,12 @@ class AsyncPoissonStrategy(ThroughputStrategy):
 
         next_delay = self._random.expovariate(self.rate)
 
+        if self._processes_lock is None:
+            raise RuntimeError("_processes_lock is None in next_request_time; was "
+                               "init_processes_timings not called?")
+        if self._offset is None:
+            raise RuntimeError("_offset is None in next_request_time; was "
+                               "init_processes_timings not called?")
         with self._processes_lock:
             self._offset.value += next_delay
 

guidellm/scheduler/worker.py

@@ -23,11 +23,9 @@ try:
         bool, "Flag indicating uvloop availability for event loop optimization"
     ] = True
 except ImportError:
-    uvloop = None
+    uvloop = None  # type: ignore[assignment] # Optional dependency
 
-    HAS_UVLOOP: Annotated[
-        bool, "Flag indicating uvloop availability for event loop optimization"
-    ] = False
+    HAS_UVLOOP = False
 
 
 from guidellm.scheduler.schemas import (
@@ -84,6 +82,10 @@ class WorkerProcess(Generic[RequestT, ResponseT]):
                 RequestT | MultiTurnRequestT[RequestT],
                 RequestInfo,
             ],
+            tuple[
+                RequestT | MultiTurnRequestT[RequestT],
+                RequestInfo,
+            ],
         ],
         backend: BackendInterface[RequestT, ResponseT],
         strategy: SchedulingStrategy,
@@ -201,8 +203,11 @@ class WorkerProcess(Generic[RequestT, ResponseT]):
 
     async def _stop_monitor(
         self,
-    ) -> Literal["error_event", "shutdown_event"]:
-        """Monitor shutdown and error events for worker termination."""
+    ) -> None:
+        """
+        Monitor shutdown and error events for worker termination.
+        :raises RuntimeError if the work process received an error signal.
+        """
         exit_key = await wait_for_sync_objects(
             {
                 "error_event": self.error_event,
@@ -322,7 +327,7 @@ class WorkerProcess(Generic[RequestT, ResponseT]):
         """Cancel all remaining queued requests until worker process terminates."""
         while True:
             try:
-                request: RequestT
+                request: RequestT | MultiTurnRequestT[RequestT]
                 request_info: RequestInfo
                 request, request_info = await self.messaging.get(
                     timeout=self.messaging.poll_interval
@@ -350,31 +355,19 @@ class WorkerProcess(Generic[RequestT, ResponseT]):
 
         try:
             # Pull request from the queue, update state, and send "pending" update
-            request, request_info = await self.messaging.get()
-            request_info.timings.dequeued = time.time()
-            request_info.scheduler_node_id = self.messaging.worker_index or -1
-            request_info.timings.targeted_start = target_start
-            self._send_update("pending", response, request, request_info)
-
-            if request is None or request_info is None:
-                raise RuntimeError("Received invalid request or request info")
-            if isinstance(request, list | tuple):
-                raise NotImplementedError("Multi-turn requests are not yet supported")
-
-            # Schedule the request
-            current_time = time.time()
-            request_info.timings.scheduled_at = current_time
-            if target_start > current_time:
-                await asyncio.sleep(target_start - current_time)
-                # Adapt delay so that scheduled at reflects the sleep time
-                request_info.timings.scheduled_at = target_start
-
-            # Process the request with the backend
-            request_info.timings.resolve_start = time.time()
-            self._send_update("in_progress", response, request, request_info)
-            async for resp, info in self.backend.resolve(request, request_info, None):
+            request, request_info = await self._dequeue_next_request(target_start)
+
+            # Schedule the request and send "in_progress" update
+            await self._schedule_request(request, request_info, target_start)
+
+            async for resp, info in self.backend.resolve(  # type: ignore[attr-defined]
+                request, request_info, None
+            ):
+
                 response = resp
                 request_info = info
+                if request_info is None:
+                    raise RuntimeError("Received invalid request info from backend")
 
             # Complete the request
             request_info.timings.resolve_end = time.time()
@@ -397,6 +390,39 @@ class WorkerProcess(Generic[RequestT, ResponseT]):
             if request_info is not None:
                 self.strategy.request_completed(request_info)
 
+    async def _dequeue_next_request(
+        self, target_start: float
+    ) -> tuple[RequestT, RequestInfo]:
+        request, request_info = await self.messaging.get()
+        dequeued_time = time.time()  # Ensure accurate dequeue timing
+        if request is None or request_info is None:
+            raise RuntimeError("Received invalid request or request info")
+        if isinstance(request, list | tuple):
+            raise NotImplementedError("Multi-turn requests are not yet supported")
+
+        request_info.timings.dequeued = dequeued_time
+        request_info.scheduler_node_id = self.messaging.worker_index or -1
+        request_info.timings.targeted_start = target_start
+        self._send_update("pending", None, request, request_info)
+        return request, request_info
+
+    async def _schedule_request(
+        self,
+        request: RequestT,
+        request_info: RequestInfo,
+        target_start: float
+    ):
+        current_time = time.time()
+        request_info.timings.scheduled_at = current_time
+        if target_start > current_time:
+            await asyncio.sleep(target_start - current_time)
+            # Adapt delay so that scheduled at reflects the sleep time
+            request_info.timings.scheduled_at = target_start
+
+        # Process the request with the backend
+        request_info.timings.resolve_start = time.time()
+        self._send_update("in_progress", None, request, request_info)
+
     def _send_update(
         self,
         new_status: Literal[

guidellm/scheduler/worker_group.py

@@ -84,7 +84,7 @@ class WorkerProcessGroup(Generic[RequestT, ResponseT]):
         backend: BackendInterface[RequestT, ResponseT],
         strategy: SchedulingStrategy,
         startup_duration: float,
-        **constraints: dict[str, Constraint],
+        **constraints: Constraint,
     ):
         """
         Initialize a worker process group for distributed request processing.
@@ -232,7 +232,7 @@ class WorkerProcessGroup(Generic[RequestT, ResponseT]):
                     worker_index=rank,
                     max_buffer_send_size=None,
                     max_buffer_receive_size=per_proc_max_buffer_size,
-                ),
+                ),  # The non-group worker lacks the SchedulerState type. Type err.
                 backend=self.backend,
                 strategy=self.strategy,
                 async_limit=async_limit,
@@ -478,9 +478,9 @@ class WorkerGroupState(Generic[RequestT, ResponseT]):
             num_processes=len(processes),
             start_time=start_time,
         )
-        self._queued_requests: set[RequestT | MultiTurnRequestT[RequestT]] = set()
-        self._pending_requests: set[RequestT | MultiTurnRequestT[RequestT]] = set()
-        self._processing_requests: set[RequestT | MultiTurnRequestT[RequestT]] = set()
+        self._queued_request_ids: set[str] = set()
+        self._pending_request_ids: set[str] = set()
+        self._processing_request_ids: set[str] = set()
 
     def requests_generator(
         self, requests: Iterable[RequestT | MultiTurnRequestT[RequestT]]
@@ -517,11 +517,13 @@ class WorkerGroupState(Generic[RequestT, ResponseT]):
                 )
                 state_update = self._locked_update(request_info)
                 request_info.timings.queued = time.time()
+                if self.messaging.buffer_receive_queue is None:
+                    raise RuntimeError("buffer receive queue is None")
                 self.messaging.buffer_receive_queue.sync_put(
                     (None, request, request_info, state_update.state)
                 )
 
-                yield (request, request_info)
+                yield request, request_info
 
                 if state_update.stop_queueing:
                     self.stop_send_requests_event.set()
@@ -530,8 +532,8 @@ class WorkerGroupState(Generic[RequestT, ResponseT]):
             # Reached the end, inject a RequestsExhaustedConstraint to record
             self._locked_update(
                 info=None,
-                requests_exhausted={
-                    "requests_exhausted": RequestsExhaustedConstraint(
+                add_constraints={
+                    "requests_exhausted": RequestsExhaustedConstraint(  # type: ignore[dict-item]
                         num_requests=count
                     )
                 },
@@ -610,10 +612,10 @@ class WorkerGroupState(Generic[RequestT, ResponseT]):
     def _locked_update(
         self,
         info: RequestInfo | None = None,
-        **add_constraints: dict[str, Constraint],
+        add_constraints: dict[str, Constraint] | None = None,
     ) -> _StateUpdate:
         with self._update_lock:
-            if add_constraints:
+            if add_constraints is not None:
                 self.constraints.update(add_constraints)
 
             if info is not None:
@@ -631,34 +633,34 @@ class WorkerGroupState(Generic[RequestT, ResponseT]):
 
     def _update_state_request_counts(self, info: RequestInfo):
         if info.status == "queued":
-            self._queued_requests.add(info.request_id)
-            self._state.queued_requests = len(self._queued_requests)
+            self._queued_request_ids.add(info.request_id)
+            self._state.queued_requests = len(self._queued_request_ids)
             self._state.created_requests += 1
         elif info.status == "pending":
-            self._queued_requests.remove(info.request_id)
-            self._state.queued_requests = len(self._queued_requests)
-            self._pending_requests.add(info.request_id)
-            self._state.pending_requests = len(self._pending_requests)
+            self._queued_request_ids.remove(info.request_id)
+            self._state.queued_requests = len(self._queued_request_ids)
+            self._pending_request_ids.add(info.request_id)
+            self._state.pending_requests = len(self._pending_request_ids)
         elif info.status == "in_progress":
-            self._pending_requests.remove(info.request_id)
-            self._state.pending_requests = len(self._pending_requests)
-            self._processing_requests.add(info.request_id)
-            self._state.processing_requests = len(self._processing_requests)
+            self._pending_request_ids.remove(info.request_id)
+            self._state.pending_requests = len(self._pending_request_ids)
+            self._processing_request_ids.add(info.request_id)
+            self._state.processing_requests = len(self._processing_request_ids)
         elif info.status == "completed":
-            self._processing_requests.remove(info.request_id)
-            self._state.processing_requests = len(self._processing_requests)
+            self._processing_request_ids.remove(info.request_id)
+            self._state.processing_requests = len(self._processing_request_ids)
             self._state.processed_requests += 1
             self._state.successful_requests += 1
         elif info.status in ("errored", "cancelled"):
-            if info.request_id in self._queued_requests:
-                self._queued_requests.remove(info.request_id)
-                self._state.queued_requests = len(self._queued_requests)
-            elif info.request_id in self._pending_requests:
-                self._pending_requests.remove(info.request_id)
-                self._state.pending_requests = len(self._pending_requests)
-            elif info.request_id in self._processing_requests:
-                self._processing_requests.remove(info.request_id)
-                self._state.processing_requests = len(self._processing_requests)
+            if info.request_id in self._queued_request_ids:
+                self._queued_request_ids.remove(info.request_id)
+                self._state.queued_requests = len(self._queued_request_ids)
+            elif info.request_id in self._pending_request_ids:
+                self._pending_request_ids.remove(info.request_id)
+                self._state.pending_requests = len(self._pending_request_ids)
+            elif info.request_id in self._processing_request_ids:
+                self._processing_request_ids.remove(info.request_id)
+                self._state.processing_requests = len(self._processing_request_ids)
 
             self._state.processed_requests += 1
             self._state.errored_requests += 1 if info.status == "errored" else 0

guidellm/schemas/request.py

@@ -169,6 +169,16 @@ class UsageMetrics(StandardBaseDict):
             self.video_tokens or 0
         ) + (self.audio_tokens or 0) or None
 
+    def add_text_metrics(self, text):
+        """
+        Adds the metrics from the given text to the fields
+        `text_characters` and `text_words`.
+
+        :param text: Text to add metrics from
+        """
+        self.text_characters = (self.text_characters or 0) + len(text)
+        self.text_words = (self.text_words or 0) + len(text.split())
+
 
 class GenerationRequest(StandardBaseModel):
     """

guidellm/utils/cli.py

@@ -3,9 +3,34 @@ from typing import Any
 
 import click
 
-__all__ = ["Union", "format_list_arg", "parse_json", "set_if_not_default"]
+__all__ = [
+    "Union",
+    "format_list_arg",
+    "parse_json",
+    "parse_list_floats",
+    "set_if_not_default",
+]
 
 
+def parse_list_floats(ctx, param, value):  # noqa: ARG001
+    """
+    Callback to parse a comma-separated string into a list of floats.
+    """
+    # This callback only runs if the --rate option is provided by the user.
+    # If it's not, 'value' will be None, and Click will use the 'default'.
+    if value is None:
+        return None  # Keep the default
+
+    try:
+        # Split by comma, strip any whitespace, and convert to float
+        return [float(item.strip()) for item in value.split(",")]
+    except ValueError as e:
+        # Raise a Click error if any part isn't a valid float
+        raise click.BadParameter(
+            f"Value '{value}' is not a valid comma-separated list "
+            f"of floats/ints. Error: {e}"
+        ) from e
+
 def parse_json(ctx, param, value):  # noqa: ARG001
     if value is None or value == [None]:
         return None

{guidellm-0.4.0a155.dist-info → guidellm-0.4.0a173.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guidellm
-Version: 0.4.0a155
+Version: 0.4.0a173
 Summary: Guidance platform for deploying and managing large language models.
 Author: Red Hat
 License: Apache-2.0

{guidellm-0.4.0a155.dist-info → guidellm-0.4.0a173.dist-info}/RECORD

@@ -1,5 +1,5 @@
 guidellm/__init__.py,sha256=1zl-PT9IZJvDfdLSMviPLzhVE3_ZXpizmc9s7UWa6kQ,1206
-guidellm/__main__.py,sha256=bzKBbZP4qXx9u5QhYZTp6tWqqf5NpcGfTxAUV3giKbA,20512
+guidellm/__main__.py,sha256=uU5K-QV7rHBARdSTwsNRAPLVoTVT5NQ6DoHx7jssZyc,20554
 guidellm/logger.py,sha256=6qGOeff8hOJF6p57Zietq6qr64N7E40CJSQSQcUFgKc,2912
 guidellm/settings.py,sha256=C4miDtWaI5lJ4NBXxfuUitt5-6_FCzZPzM1Bjie9XoA,7283
 guidellm/version.py,sha256=NIzyWA7lNdSpf2MtPJuOjvW5h6E9nGDea2G4nGFDbgY,127
@@ -8,33 +8,32 @@ guidellm/backends/backend.py,sha256=Qz7z3s6rWwdYGVC-CbPvSFKWSsPiJsSFKBFyfvBG6rY,
 guidellm/backends/openai.py,sha256=0At-DMt3_kD0Qa788j_HJ1BcFiUh-SFReoYyaTy8k1g,13007
 guidellm/backends/response_handlers.py,sha256=jwoAGzy-BXxYzMroq08dEUA5ooWoscRpGdU5I4cCEUw,17136
 guidellm/benchmark/__init__.py,sha256=E9g3x0Peopsapw6Pkk9AAthUv3tIOaH59Ai6_92xnzM,2337
-guidellm/benchmark/benchmarker.py,sha256=I3pgAUQSnp1TFrDDGqZ5El-ZQRYyLQer4cfEyI16NVQ,6444
-guidellm/benchmark/entrypoints.py,sha256=hbuluEL4Hlj5IOgaagANyzWauMp8kxIv83UytXQYLDI,17938
-guidellm/benchmark/output.py,sha256=dLlZFCOaAvNZmdsMGzXFdPFKIvM_H63uurxWh4dj69U,27243
+guidellm/benchmark/benchmarker.py,sha256=wZNStFlAcygFBPPA5aee9RipXr-jq-GiH8dUUrijwvo,6500
+guidellm/benchmark/entrypoints.py,sha256=U_0JvZYCkQ1Z-qkF8tN_JeuhuGn8mINScwi819bdzl8,17962
+guidellm/benchmark/output.py,sha256=jHa7u6wTh_YSBdO2oDo47079KReXHZ-AKB6zgo8SMvg,27308
 guidellm/benchmark/profile.py,sha256=RvQdmVLNLU-V8U8xIXm3vH8tY7Hp_4jNPQe5dombj8g,24007
 guidellm/benchmark/progress.py,sha256=oZqZZ_vInmifBNd490ZTgcCjaGy2_slViEABSWDJgHI,25976
-guidellm/benchmark/schemas.py,sha256=pULZ0F0HbubtRDQBrU9XhJqY0me2GK8IdAXjcqLaRk0,81246
+guidellm/benchmark/schemas.py,sha256=eC6WXTXoY3-6Q4SSBLs7VtgfLSilwP9FhsHdRH-6fr4,81249
 guidellm/benchmark/scenarios/__init__.py,sha256=SmaYf8hfByJU4LVJ7pZKNxJPYBObl7UKpoaJEmLPdTI,1276
 guidellm/benchmark/scenarios/chat.json,sha256=4H_ByPCv_9azHn6iTxCY3FfpoUtlbShDPdNyzDwHJVQ,226
 guidellm/benchmark/scenarios/rag.json,sha256=BIpifJoAtWgB3NRRYK51ZuCH4Zvh1OeBFanB7vcxS-E,231
 guidellm/data/__init__.py,sha256=0-7B9vBgY6QHT4svxnBhGN4DoA4jE_9HZxOgndyOiUM,743
 guidellm/data/collators.py,sha256=j4OLGqwbt4sNnTqE8iSbe11qmgJBHnyWjipNeEz1SCk,445
-guidellm/data/loaders.py,sha256=OcZh2-Mlt4ZQ6xAI5tpRp3THiYMBGT0DZEQrYupjBdA,5105
-guidellm/data/processor.py,sha256=8IzCiAr3n-6RAFZrr5dMfsh-7hpK2xF9s_xSQVRK0Mo,807
+guidellm/data/loaders.py,sha256=4JxpnOXD-Oju9TcyBumW2JRLFqMo8-EIHN5DpKZJmCA,5413
+guidellm/data/processor.py,sha256=HjSdXKJ67Y2tqcxNoP4LWkefNDLzuN_5nM8MXW_RVec,854
 guidellm/data/schemas.py,sha256=6KUv2OPW_f369SzEhyPBXPDMGoQtJzEPJalBCpp3f84,280
 guidellm/data/deserializers/__init__.py,sha256=NhfbgebOun2FgWTNPydto2f3LNSTlOqdaxeFpDvQUhY,1608
-guidellm/data/deserializers/deserializer.py,sha256=tNmMFUbCsIFnaWJ6vEXrie0jAUKlVA4Gyl7hhnetiEk,3805
-guidellm/data/deserializers/file.py,sha256=6XVc8MrHnHAc06hVXb_X0TH2DAL9S-oIXcK2HPMj9SI,7501
-guidellm/data/deserializers/huggingface.py,sha256=p4eN_jjuM_ChtyLcQy4QrTEW-tpsf3mIfYm3GGK-1JQ,2908
-guidellm/data/deserializers/memory.py,sha256=4u--QmbxyKgU2asNFo-a7DjKLSlH0ggSb6T8axVsevM,6621
-guidellm/data/deserializers/synthetic.py,sha256=tFs3Z6_ZwY-UdScJWXbswAZ31fVW8p9ISuOQM1qCvZM,12069
+guidellm/data/deserializers/deserializer.py,sha256=SOCtXik1fVeS7yHgNFMihkq3RmqA-klgmLJULVmSjFU,5007
+guidellm/data/deserializers/file.py,sha256=PzFOJcPuXrUM-OK6EbDIKhzEXDPp7X4xfe_wHZxXqKw,7445
+guidellm/data/deserializers/huggingface.py,sha256=uk2WBH9WJ8csaRrw6wXQ5Xiz_pj_fN5c4jDV9pWf1F0,2954
+guidellm/data/deserializers/memory.py,sha256=F6o2JwIUgcZHdeRkT051AS76i6wWlIw-XGH09_pOqDs,6670
+guidellm/data/deserializers/synthetic.py,sha256=Gcx39gwW0ZvFQSplMfT4ULXfGAVp2v7YiByKmRH5C7Y,12188
 guidellm/data/preprocessors/__init__.py,sha256=khp1-m5EqJ6I40qFAYVv71LncrEXzKBmRocxQG5-ZuE,757
-guidellm/data/preprocessors/formatters.py,sha256=DV_-29rFuSqV7yyQETJ92FBPG9yrkOacEE1nhxXRVyc,14764
-guidellm/data/preprocessors/mappers.py,sha256=nn2zXkabgv0NVT4Iods-cJ3UGsdCpCsqDi81b7K9M_k,6769
-guidellm/data/preprocessors/preprocessor.py,sha256=7_9qezg820_JqEPizoIlGtMxZgEox17V2MxUHfkz5J8,747
-guidellm/data/utils/__init__.py,sha256=lsVIrDXiZgLXdGDeNqm4y5Ilai6jiMOpxVhyFap5ocA,186
-guidellm/data/utils/dataset.py,sha256=8VO7n_6F4ARSXitvzOCngtO-WokNfFb25lA-mijS7UE,2325
-guidellm/data/utils/functions.py,sha256=cuNCTzhiqFUCBpvwwVMgBqQORGz4q1XS3FUfXdxw-gQ,390
+guidellm/data/preprocessors/formatters.py,sha256=F5BHtJZ6PdmevS9LI6e9TJPwUKnuSsZbt7qS8n2H_eM,14078
+guidellm/data/preprocessors/mappers.py,sha256=7UBdRF2cdADqPbsri_1Mv3FhsQLJtUoIe_lSBV9owEQ,6715
+guidellm/data/preprocessors/preprocessor.py,sha256=OqzAaabEG0v3VSxBfKEVda3ZnTmVjn4OesB2AOC9rhA,812
+guidellm/data/utils/__init__.py,sha256=A8cJqUC7UVSr3upkkD6PzONGQUkjSV9HhMp31NJbI7E,125
+guidellm/data/utils/dataset.py,sha256=ZaKlgGM_L6gcHghAfo5vG0NaHzPtpDWHddD1KX7E7_c,2323
 guidellm/extras/__init__.py,sha256=bNtt6CNDhwMM5XlL1q74j_df-1xoXavTShB05LjDYMw,96
 guidellm/extras/audio.py,sha256=ECDK5IFFBhfae1UQrOGGQCE_7wSCuTySo-TThpm4WfU,6421
 guidellm/extras/vision.py,sha256=hU8e7ryUnMZOT6_utR9GKhayvCXYPljeSwCx8S4-nIQ,7691
@@ -54,21 +53,21 @@ guidellm/presentation/builder.py,sha256=eSKsUUx7RbmsqgMRKxcaMuYqquanzS5moc8Uv9TI
 guidellm/presentation/data_models.py,sha256=1CjeHaevj2r4oHLcBQeDY0BQ9VXTol46KULr3F-ps48,7424
 guidellm/presentation/injector.py,sha256=mDo0hvrh4NE2c4RZK5GoegtzWVcvw_zEpvm5sRy7xGE,1834
 guidellm/scheduler/__init__.py,sha256=dj-RZDd5B6H6mt7dPAYGDayqa2k6ngqwfKgRUeCkwDw,2511
-guidellm/scheduler/constraints.py,sha256=a_cDJtmREU1rpbJ1UYxsdH9xW5fnOYd_uLj3VbfStb0,39590
-guidellm/scheduler/environments.py,sha256=W_kp2dICO7Z-NWoji9MwgDu0HjPDhUJNGXyll_LL45Y,8829
-guidellm/scheduler/scheduler.py,sha256=7y3PMAmkNwEYQt-I5ZPkilZZIaw1ad3Hs7z6ZgtQVBw,6986
+guidellm/scheduler/constraints.py,sha256=MtuqMTtsiyDTzC7kEZzheqqvfgnsY45bhvaOmGDOrL8,39553
+guidellm/scheduler/environments.py,sha256=eRQ9eLvQ61Yyo3nN_leYHTerla9mPuhr8tJD6_30XtM,8889
+guidellm/scheduler/scheduler.py,sha256=_svO8hMJt4aNFHOjndi5Ac-GW7R7J1AVO9k3x_vzehY,7016
 guidellm/scheduler/schemas.py,sha256=iVxT0GaDK8q8ruuCL5D4046WrCf7X4v2KeZWfP8gdng,9461
-guidellm/scheduler/strategies.py,sha256=LfYogQCubT3eCKKEUQBWcsBh19kg8J5_9NZz77YAlGc,17796
-guidellm/scheduler/worker.py,sha256=4-RBw1znsR_Fv4O4agT1XEHETp7Fz9TOaOMBRIBm7-U,17157
-guidellm/scheduler/worker_group.py,sha256=czOxgbWJ0BKBqa0HOdqt09-n-xR4VUkiatJHsOCbJio,28597
+guidellm/scheduler/strategies.py,sha256=hZbZfeUCTqIBnY30J7m7QwBMPiyLQ6LlqmRVNyrI_Vs,19182
+guidellm/scheduler/worker.py,sha256=hXM0TpbwDakduRdGaSRShPnHDj-ZQJw2eVlRnagk8FM,17979
+guidellm/scheduler/worker_group.py,sha256=l8T-IoitC--bBqhNhWhPM9rKofNfRlJX6HyzS2hBtBA,28799
 guidellm/schemas/__init__.py,sha256=4odN5dEqgRQaxsPpYLnyls0JAlDoEhbWnbYTnPZspN8,879
 guidellm/schemas/info.py,sha256=A_LVqpQteCQvf6XXPi02m1pYX2-vOtCEswLLTZfa9_Y,5678
-guidellm/schemas/request.py,sha256=K25Ph56nyhFMA9pzzX52uo4dG0K_Agb7paUvKsafAaI,7567
+guidellm/schemas/request.py,sha256=YoOV6zmHFF9LoNZdF8810H9H3d9BEoNXufUzqTteH7g,7920
 guidellm/schemas/response.py,sha256=ROesx1rDI7g1jRoGbZjmGROazBxcT-3NVwQTIhwI2O4,4578
 guidellm/schemas/stats.py,sha256=4FPdMtoAVv-vQMLTaWYgIcqof7z6_nLHxYGV_lD1L9g,7507
 guidellm/utils/__init__.py,sha256=XGBV3fdETLihLn97_Sd0KM1B4hneoe3d1Oh0nMKObv8,3040
 guidellm/utils/auto_importer.py,sha256=rkraMx815TasixoFn0bwtp--7V7TxuEvfZUVFB8V5L0,3658
-guidellm/utils/cli.py,sha256=kw7A0HSTZaZDdAElHczo1WLCcL9DVlt13HG3a9mu_00,3545
+guidellm/utils/cli.py,sha256=oMqLEw2pk9aCYQEuwmSsTO349Mil5Q6CKwocW3akmLo,4343
 guidellm/utils/colors.py,sha256=D0IGz8A346-Pt5qgnP3S5uV-VgngJoXbfToVCOna41k,175
 guidellm/utils/console.py,sha256=IC9vZ0PpwW9SxReZA3BGXyNRK20tdV0FDNuUmbMwUlE,4382
 guidellm/utils/default_group.py,sha256=iZ47bwRcUCxkX04Zdg0qpmqKtFg4P7lt5_hpw1CnKkA,4167
@@ -88,9 +87,9 @@ guidellm/utils/statistics.py,sha256=KzUYm4fVNVtDd6FRCRBnqYmFcea-9n0JKCAZyqeZLM8,
 guidellm/utils/synchronous.py,sha256=rRkWwbDf1ty607KUhDKsqV4HcdKU5o0-1s5hwdG-Hak,5209
 guidellm/utils/text.py,sha256=0K8yUEB4gzztevxzuiMXossSoHhvzcHoKqRhQYQdOrg,11644
 guidellm/utils/typing.py,sha256=jt0o7SRbDhnvrifR3l4hN8oL3uJNxl8aMnvaoABb-MU,1235
-guidellm-0.4.0a155.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-guidellm-0.4.0a155.dist-info/METADATA,sha256=AEyyL1EHQ5t9SiABaf8IN5VxX3nB710-2pguCKQXw4o,21923
-guidellm-0.4.0a155.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guidellm-0.4.0a155.dist-info/entry_points.txt,sha256=DzLFEg47fF7qY1b-9laPz9jg0KSKJ1_D9TbF93kLz_E,51
-guidellm-0.4.0a155.dist-info/top_level.txt,sha256=EXRGjnvFtL6MeZTe0tnHRMYcEWUW3vEqoG2zO7vFOtk,9
-guidellm-0.4.0a155.dist-info/RECORD,,
+guidellm-0.4.0a173.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+guidellm-0.4.0a173.dist-info/METADATA,sha256=tgoCM_1UQSUh_WYNTeUKrZehj6HJUVJnwDzkmCRhEMY,21923
+guidellm-0.4.0a173.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guidellm-0.4.0a173.dist-info/entry_points.txt,sha256=DzLFEg47fF7qY1b-9laPz9jg0KSKJ1_D9TbF93kLz_E,51
+guidellm-0.4.0a173.dist-info/top_level.txt,sha256=EXRGjnvFtL6MeZTe0tnHRMYcEWUW3vEqoG2zO7vFOtk,9
+guidellm-0.4.0a173.dist-info/RECORD,,